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

internal/api/friend/friend1.go

@@ -5,27 +5,53 @@ import (
 	api "Open_IM/pkg/base_info"
 	"Open_IM/pkg/common/config"
 	rpc "Open_IM/pkg/proto/friend"
-	"Open_IM/pkg/utils"
 	"github.com/gin-gonic/gin"
 )
 
-// 不一致
-func AddBlacklist(c *gin.Context) {
-	common.ApiToRpc(c, &api.AddBlacklistReq{}, &api.AddBlacklistResp{},
-		config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, utils.GetSelfFuncName())
+func AddBlack(c *gin.Context) {
+	common.ApiToRpc(c, &api.AddBlacklistReq{}, &api.AddBlacklistResp{}, config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, "")
 }
 
-func ImportFriend1(c *gin.Context) {
-	common.ApiToRpc(c, &api.ImportFriendReq{}, &api.ImportFriendResp{},
-		config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, utils.GetSelfFuncName())
+func ImportFriend(c *gin.Context) {
+	common.ApiToRpc(c, &api.ImportFriendReq{}, &api.ImportFriendResp{}, config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, "")
 }
 
-func AddFriend1(c *gin.Context) {
-	common.ApiToRpc(c, &api.AddFriendReq{}, &api.AddFriendResp{},
-		config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, utils.GetSelfFuncName())
+func AddFriend(c *gin.Context) {
+	common.ApiToRpc(c, &api.AddFriendReq{}, &api.AddFriendResp{}, config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, "")
 }
 
-func AddFriendResponse1(c *gin.Context) {
-	common.ApiToRpc(c, &api.AddFriendResponseReq{}, &api.AddFriendResponseResp{},
-		config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, utils.GetSelfFuncName())
+func AddFriendResponse(c *gin.Context) {
+	common.ApiToRpc(c, &api.AddFriendResponseReq{}, &api.AddFriendResponseResp{}, config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, "")
+}
+
+func DeleteFriend(c *gin.Context) {
+	common.ApiToRpc(c, &api.DeleteFriendReq{}, &api.DeleteFriendResp{}, config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, "")
+}
+
+func GetBlacklist(c *gin.Context) {
+	common.ApiToRpc(c, &api.GetBlackListReq{}, &api.GetBlackListResp{}, config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, "")
+}
+
+func SetFriendRemark(c *gin.Context) {
+	common.ApiToRpc(c, &api.SetFriendRemarkReq{}, &api.SetFriendRemarkResp{}, config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, "")
+}
+
+func RemoveBlacklist(c *gin.Context) {
+	common.ApiToRpc(c, &api.RemoveBlacklistReq{}, &api.RemoveBlacklistResp{}, config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, "")
+}
+
+func IsFriend(c *gin.Context) {
+	common.ApiToRpc(c, &api.IsFriendReq{}, &api.IsFriendResp{}, config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, "")
+}
+
+func GetFriendList(c *gin.Context) {
+	common.ApiToRpc(c, &api.GetFriendListReq{}, &api.GetFriendListResp{}, config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, "")
+}
+
+func GetFriendApplyList(c *gin.Context) {
+	common.ApiToRpc(c, &api.GetFriendApplyListReq{}, &api.GetFriendApplyListResp{}, config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, "")
+}
+
+func GetSelfApplyList(c *gin.Context) {
+	common.ApiToRpc(c, &api.GetSelfApplyListReq{}, &api.GetSelfApplyListResp{}, config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, "")
 }

internal/api_to_rpc/api.go

@@ -12,48 +12,43 @@ import (
 )
 
 func ApiToRpc(c *gin.Context, apiReq, apiResp interface{}, rpcName string, rpcClientFunc interface{}, rpcFuncName string) {
+	if rpcName == "" {
+		rpcName = utils2.GetFuncName(1)
+	}
 	logFuncName := fmt.Sprintf("[ApiToRpc: %s]%s", utils2.GetFuncName(1), rpcFuncName)
-	operationID := c.GetHeader("operationID")
-	nCtx := trace_log.NewCtx1(c, rpcFuncName, operationID)
-	defer log.ShowLog(nCtx)
+	ctx := trace_log.NewCtx1(c, rpcFuncName)
+	defer log.ShowLog(ctx)
 	if err := c.BindJSON(apiReq); err != nil {
-		trace_log.WriteErrorResponse(nCtx, "BindJSON", err)
+		trace_log.WriteErrorResponse(ctx, "BindJSON", err)
 		return
 	}
-	trace_log.SetCtxInfo(nCtx, logFuncName, nil, "apiReq", apiReq)
-	etcdConn, err := getcdv3.GetConn(nCtx, rpcName)
+	trace_log.SetCtxInfo(ctx, logFuncName, nil, "apiReq", apiReq)
+	etcdConn, err := getcdv3.GetConn(ctx, rpcName)
 	if err != nil {
-		trace_log.WriteErrorResponse(nCtx, "GetConn", err)
+		trace_log.WriteErrorResponse(ctx, "GetConn", err)
 		return
 	}
-	rpc := reflect.ValueOf(rpcClientFunc).Call([]reflect.Value{
+	rpcClient := reflect.ValueOf(rpcClientFunc).Call([]reflect.Value{
 		reflect.ValueOf(etcdConn),
-	})[0].MethodByName(rpcFuncName) // rpc func
-	rpcReqPtr := reflect.New(rpc.Type().In(1).Elem()) // *req参数
-	//if err := utils.CopyStructFields(rpcReqPtr.Interface(), apiReq); err != nil {
-	//	trace_log.WriteErrorResponse(nCtx, "CopyStructFields_RpcReq", err)
-	//	return
-	//}
+	})[0].MethodByName(rpcFuncName) // rpcClient func
+	rpcReqPtr := reflect.New(rpcClient.Type().In(1).Elem()) // *req
 	CopyAny(apiReq, rpcReqPtr.Interface())
-	trace_log.SetCtxInfo(nCtx, logFuncName, nil, "opUserID", c.GetString("opUserID"), "callRpcReq", rpcString(rpcReqPtr.Elem().Interface()))
-	respArr := rpc.Call([]reflect.Value{
-		reflect.ValueOf(context.Context(c)), // context.Context
-		rpcReqPtr,                           // rpc apiReq
+	trace_log.SetCtxInfo(ctx, logFuncName, nil, "opUserID", c.GetString("opUserID"), "callRpcReq", rpcString(rpcReqPtr.Elem().Interface()))
+	respArr := rpcClient.Call([]reflect.Value{
+		reflect.ValueOf(context.Context(c)), // context.Context (ctx operationID. opUserID)
+		rpcReqPtr,                           // rpcClient apiReq
 	}) // respArr => (apiResp, error)
-	if !respArr[1].IsNil() { // rpc err != nil
+	if !respArr[1].IsNil() { // rpcClient err != nil
 		err := respArr[1].Interface().(error)
-		trace_log.WriteErrorResponse(nCtx, rpcFuncName, err, "callRpcResp", "error")
+		trace_log.WriteErrorResponse(ctx, rpcFuncName, err, "callRpcResp", "error")
 		return
 	}
 	rpcResp := respArr[0].Elem()
-	trace_log.SetCtxInfo(nCtx, rpcFuncName, nil, "callRpcResp", rpcString(rpcResp.Interface()))
+	trace_log.SetCtxInfo(ctx, rpcFuncName, nil, "callRpcResp", rpcString(rpcResp.Interface()))
 	if apiResp != nil {
-		//if err := utils.CopyStructFields(apiResp, rpcResp.Interface()); err != nil {
-		//	trace_log.SetCtxInfo(nCtx, "CopyStructFields_RpcResp", err, "apiResp", fmt.Sprintf("%T", apiResp), "rpcResp", fmt.Sprintf("%T", rpcResp.Interface()))
-		//}
 		CopyAny(rpcResp.Interface(), apiResp)
 	}
-	trace_log.SetSuccess(nCtx, rpcFuncName, apiResp)
+	trace_log.SetSuccess(ctx, rpcFuncName, apiResp)
 }
 
 func rpcString(v interface{}) string {
@@ -62,77 +57,3 @@ func rpcString(v interface{}) string {
 	}
 	return fmt.Sprintf("%+v", v)
 }
-
-//func ApiToRpc(c *gin.Context, apiReq, apiResp interface{}, rpcName string, fn interface{}, rpcFuncName string, tokenFunc func(token string, operationID string) (string, error)) {
-//	nCtx := trace_log.NewCtx(c, rpcFuncName)
-//	defer trace_log.ShowLog(nCtx)
-//	if err := c.BindJSON(apiReq); err != nil {
-//		trace_log.WriteErrorResponse(nCtx, "BindJSON", err)
-//		return
-//	}
-//	reqValue := reflect.ValueOf(apiReq).Elem()
-//	operationID := reqValue.FieldByName("OperationID").String()
-//	trace_log.SetOperationID(nCtx, operationID)
-//	trace_log.SetCtxInfo(nCtx, "BindJSON", nil, "params", apiReq)
-//	etcdConn, err := utils2.GetConn(c, rpcName)
-//	if err != nil {
-//		trace_log.WriteErrorResponse(nCtx, "GetDefaultConn", err)
-//		return
-//	}
-//	rpc := reflect.ValueOf(fn).Call([]reflect.Value{
-//		reflect.ValueOf(etcdConn),
-//	})[0].MethodByName(rpcFuncName) // rpc func
-//	rpcReqPtr := reflect.New(rpc.Type().In(1).Elem()) // *req参数
-//	var opUserID string
-//	if tokenFunc != nil {
-//		var err error
-//		opUserID, err = tokenFunc(c.GetHeader("token"), operationID)
-//		if err != nil {
-//			trace_log.WriteErrorResponse(nCtx, "TokenFunc", err)
-//			return
-//		}
-//	}
-//	if opID := rpcReqPtr.Elem().FieldByName("OperationID"); opID.IsValid() {
-//		opID.SetString(operationID)
-//		if opU := rpcReqPtr.Elem().FieldByName("OpUserID"); opU.IsValid() {
-//			opU.SetString(opUserID)
-//		}
-//	} else {
-//		op := rpcReqPtr.Elem().FieldByName("Operation").Elem()
-//		op.FieldByName("OperationID").SetString(operationID)
-//		op.FieldByName("OpUserID").SetString(opUserID)
-//	}
-//	if err := utils.CopyStructFields(rpcReqPtr.Interface(), apiReq); err != nil {
-//		trace_log.WriteErrorResponse(nCtx, "CopyStructFields_RpcReq", err)
-//		return
-//	}
-//	respArr := rpc.Call([]reflect.Value{
-//		reflect.ValueOf(context.Context(c)), // context.Context
-//		rpcReqPtr,                           // rpc apiReq
-//	}) // respArr => (apiResp, error)
-//	if !respArr[1].IsNil() { // rpc err != nil
-//		err := respArr[1].Interface().(error)
-//		trace_log.WriteErrorResponse(nCtx, rpcFuncName, err, "rpc req", rpcReqPtr.Interface())
-//		return
-//	}
-//	rpcResp := respArr[0].Elem()
-//	trace_log.SetCtxInfo(nCtx, rpcFuncName, nil, "rpc req", rpcReqPtr.Interface(), "resp", rpcResp.Interface())
-//	commonResp := rpcResp.FieldByName("CommonResp").Elem()
-//	errCodeVal := commonResp.FieldByName("ErrCode")
-//	errMsgVal := commonResp.FieldByName("ErrMsg").Interface().(string)
-//	errCode := errCodeVal.Interface().(int32)
-//	if errCode != 0 {
-//		trace_log.WriteErrorResponse(nCtx, "RpcErrCode", &constant.ErrInfo{
-//			ErrCode: errCode,
-//			ErrMsg:  errMsgVal,
-//		})
-//		return
-//	}
-//	if apiResp != nil {
-//		if err := utils.CopyStructFields(apiResp, rpcResp.Interface()); err != nil {
-//			trace_log.WriteErrorResponse(nCtx, "CopyStructFields_RpcResp", err)
-//			return
-//		}
-//	}
-//	trace_log.SetSuccess(nCtx, rpcFuncName, apiResp)
-//}

internal/api_to_rpc/copy.go

@@ -6,25 +6,6 @@ import (
 	"reflect"
 )
 
-func setBaseValue(from, to reflect.Value) {
-	if isBaseNil(from) {
-		return
-	}
-	var l int
-	t := to.Type()
-	for t.Kind() == reflect.Ptr {
-		l++
-		t = t.Elem()
-	}
-	v := baseValue(from)
-	for i := 0; i < l; i++ {
-		t := reflect.New(v.Type())
-		t.Elem().Set(v)
-		v = t
-	}
-	to.Set(v)
-}
-
 func CopyAny(from, to interface{}) {
 	t := reflect.ValueOf(to)
 	if t.Kind() == reflect.Ptr {
@@ -50,31 +31,35 @@ func copyAny(from, to reflect.Value) {
 	if isBaseNil(to) {
 		to.Set(getBaseZeroValue(to.Type()))
 	}
-	btfrom := baseType(from.Type())
-	btto := baseType(to.Type())
-	if typeEq(btfrom, btto) {
+	btFrom := baseType(from.Type())
+	btTo := baseType(to.Type())
+	if btTo.Kind() == reflect.Interface || typeEq(btFrom, btTo) {
 		setBaseValue(from, to)
 		return
 	}
-	if _, ok := wrapType[btto.String()]; ok { // string -> wrapperspb.StringValue
-		val := reflect.New(btto).Elem()
+	if _, ok := wrapType[btTo.String()]; ok { // string -> wrapperspb.StringValue
+		val := reflect.New(btTo).Elem()
 		copyAny(from, val.FieldByName("Value"))
 		setBaseValue(val, to)
 		return
 	}
-	if _, ok := wrapType[btfrom.String()]; ok { // wrapperspb.StringValue -> string
+	if _, ok := wrapType[btFrom.String()]; ok { // wrapperspb.StringValue -> string
 		copyAny(baseValue(from).FieldByName("Value"), to)
 		return
 	}
-	if btfrom.Kind() == reflect.Struct && btto.Kind() == reflect.Struct {
+	if btFrom.Kind() == reflect.Struct && btTo.Kind() == reflect.Struct {
 		copyStruct(baseValue(from), baseValue(to))
 		return
 	}
-	if btfrom.Kind() == reflect.Slice && btto.Kind() == reflect.Slice {
+	if btFrom.Kind() == reflect.Slice && btTo.Kind() == reflect.Slice {
 		copySlice(baseValue(from), baseValue(to))
 		return
 	}
-	if btto.Kind() == reflect.String {
+	if btFrom.Kind() == reflect.Map && btTo.Kind() == reflect.Map {
+		copyMap(baseValue(from), baseValue(to))
+		return
+	}
+	if btTo.Kind() == reflect.String {
 		if isBaseNil(to) {
 			to.Set(getBaseZeroValue(baseType(to.Type())))
 		}
@@ -84,6 +69,26 @@ func copyAny(from, to reflect.Value) {
 	if toNumber(from, to) {
 		return
 	}
+
+}
+
+func setBaseValue(from, to reflect.Value) {
+	if isBaseNil(from) {
+		return
+	}
+	var l int
+	t := to.Type()
+	for t.Kind() == reflect.Ptr {
+		l++
+		t = t.Elem()
+	}
+	v := baseValue(from)
+	for i := 0; i < l; i++ {
+		t := reflect.New(v.Type())
+		t.Elem().Set(v)
+		v = t
+	}
+	to.Set(v)
 }
 
 func getBaseZeroValue(t reflect.Type) reflect.Value {
@@ -121,15 +126,6 @@ func baseType(t reflect.Type) reflect.Type {
 	return t
 }
 
-func baseLayer(t reflect.Type) int {
-	var layer int
-	for t.Kind() == reflect.Ptr {
-		layer++
-		t = t.Elem()
-	}
-	return layer
-}
-
 func typeEq(t1, t2 reflect.Type) bool {
 	return t1.String() == t2.String()
 }
@@ -174,59 +170,72 @@ func copySlice(from, to reflect.Value) {
 	to.Set(temp)
 }
 
+func copyMap(from, to reflect.Value) {
+	// todo copy map
+}
+
 func toString(value reflect.Value) string {
 	if value.Kind() == reflect.Slice {
 		switch value.Type().String() {
-		case "[]uint8":
+		case "[]uint8": // []byte -> []uint8
 			return string(value.Interface().([]uint8))
-		case "[]int32":
+		case "[]int32": // []rune -> []int32
 			return string(value.Interface().([]int32))
 		}
 	}
 	return fmt.Sprint(value.Interface())
 }
 
-func toNumber(from1, to1 reflect.Value) bool {
-	if isBaseNil(to1) {
-		to1.Set(getBaseZeroValue(to1.Type()))
+func toNumber(from, to reflect.Value) bool {
+	initTo := func() {
+		if isBaseNil(to) {
+			to.Set(getBaseZeroValue(to.Type()))
+		}
 	}
-	from := baseValue(from1)
-	to := baseValue(to1)
-	switch from.Kind() {
+	switch baseValue(from).Kind() {
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		switch to.Kind() {
+		switch baseValue(to).Kind() {
 		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-			to.SetInt(from.Int())
+			initTo()
+			baseValue(to).SetInt(baseValue(from).Int())
 			return true
 		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-			to.SetUint(uint64(from.Int()))
+			initTo()
+			baseValue(to).SetUint(uint64(baseValue(from).Int()))
 			return true
 		case reflect.Float64, reflect.Float32:
-			to.SetFloat(float64(from.Int()))
+			initTo()
+			baseValue(to).SetFloat(float64(baseValue(from).Int()))
 			return true
 		}
 	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		switch to.Kind() {
+		switch baseValue(to).Kind() {
 		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-			to.SetInt(int64(from.Uint()))
+			initTo()
+			baseValue(to).SetInt(int64(baseValue(from).Uint()))
 			return true
 		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-			to.SetInt(int64(from.Uint()))
+			initTo()
+			baseValue(to).SetInt(int64(baseValue(from).Uint()))
 			return true
 		case reflect.Float64, reflect.Float32:
-			to.SetFloat(float64(from.Uint()))
+			initTo()
+			baseValue(to).SetFloat(float64(baseValue(from).Uint()))
 			return true
 		}
 	case reflect.Float64, reflect.Float32:
-		switch to.Kind() {
+		switch baseValue(to).Kind() {
 		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-			to.SetInt(int64(from.Float()))
+			initTo()
+			baseValue(to).SetInt(int64(baseValue(from).Float()))
 			return true
 		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-			to.SetUint(uint64(from.Float()))
+			initTo()
+			baseValue(to).SetUint(uint64(baseValue(from).Float()))
 			return true
 		case reflect.Float64, reflect.Float32:
-			to.SetFloat(from.Float())
+			initTo()
+			baseValue(to).SetFloat(baseValue(from).Float())
 			return true
 		}
 	}

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
 		}

internal/utils/convert.go

@@ -0,0 +1,224 @@
+package utils
+
+import (
+	imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
+	sdk "Open_IM/pkg/proto/sdk_ws"
+	utils2 "Open_IM/pkg/utils"
+	utils "github.com/OpenIMSDK/open_utils"
+	"time"
+)
+
+func getUsersInfo(userIDs []string) ([]*sdk.UserInfo, error) {
+	return nil, nil
+}
+
+func getGroupOwnerInfo(groupID string) (*sdk.GroupMemberFullInfo, error) {
+	return nil, nil
+}
+func getNumberOfGroupMember(groupID string) (int32, error) {
+	return 0, nil
+}
+
+type DBFriend struct {
+	*imdb.Friend
+}
+
+type PBFriend struct {
+	*sdk.FriendInfo
+}
+
+func (db *DBFriend) convert() (*sdk.FriendInfo, error) {
+	pbFriend := &sdk.FriendInfo{FriendUser: &sdk.UserInfo{}}
+	utils.CopyStructFields(pbFriend, db)
+	user, err := getUsersInfo([]string{db.FriendUserID})
+	if err != nil {
+		return nil, err
+	}
+	utils2.CopyStructFields(pbFriend.FriendUser, user[0])
+	pbFriend.CreateTime = uint32(db.CreateTime.Unix())
+
+	pbFriend.FriendUser.CreateTime = uint32(db.CreateTime.Unix())
+	return pbFriend, nil
+}
+
+func (pb *PBFriend) convert() (*imdb.Friend, error) {
+	dbFriend := &imdb.Friend{}
+	utils2.CopyStructFields(dbFriend, pb)
+	dbFriend.FriendUserID = pb.FriendUser.UserID
+	dbFriend.CreateTime = utils2.UnixSecondToTime(int64(pb.CreateTime))
+	return dbFriend, nil
+}
+
+type DBFriendRequest struct {
+	*imdb.FriendRequest
+}
+
+type PBFriendRequest struct {
+	*sdk.FriendRequest
+}
+
+func (pb *PBFriendRequest) convert() (*imdb.FriendRequest, error) {
+	dbFriendRequest := &imdb.FriendRequest{}
+	utils.CopyStructFields(dbFriendRequest, pb)
+	dbFriendRequest.CreateTime = utils.UnixSecondToTime(int64(pb.CreateTime))
+	dbFriendRequest.HandleTime = utils.UnixSecondToTime(int64(pb.HandleTime))
+	return dbFriendRequest, nil
+}
+func (db *DBFriendRequest) convert() (*sdk.FriendRequest, error) {
+	pbFriendRequest := &sdk.FriendRequest{}
+	utils.CopyStructFields(pbFriendRequest, db)
+	user, err := getUsersInfo([]string{db.FromUserID})
+	if err != nil {
+		return nil, err
+	}
+	pbFriendRequest.FromNickname = user[0].Nickname
+	pbFriendRequest.FromFaceURL = user[0].FaceURL
+	pbFriendRequest.FromGender = user[0].Gender
+	user, err = getUsersInfo([]string{db.ToUserID})
+	if err != nil {
+		return nil, err
+	}
+	pbFriendRequest.ToNickname = user[0].Nickname
+	pbFriendRequest.ToFaceURL = user[0].FaceURL
+	pbFriendRequest.ToGender = user[0].Gender
+	pbFriendRequest.CreateTime = uint32(db.CreateTime.Unix())
+	pbFriendRequest.HandleTime = uint32(db.HandleTime.Unix())
+	return pbFriendRequest, nil
+}
+
+type DBBlack struct {
+	*imdb.Black
+}
+
+type PBBlack struct {
+	*sdk.BlackInfo
+}
+
+func (pb *PBBlack) convert() (*imdb.Black, error) {
+	dbBlack := &imdb.Black{}
+	dbBlack.BlockUserID = pb.BlackUserInfo.UserID
+	dbBlack.CreateTime = utils.UnixSecondToTime(int64(pb.CreateTime))
+	return dbBlack, nil
+}
+func (db *DBBlack) convert() (*sdk.BlackInfo, error) {
+	pbBlack := &sdk.BlackInfo{}
+	utils.CopyStructFields(pbBlack, db)
+	pbBlack.CreateTime = uint32(db.CreateTime.Unix())
+	user, err := getUsersInfo([]string{db.BlockUserID})
+	if err != nil {
+		return nil, err
+	}
+	utils.CopyStructFields(pbBlack.BlackUserInfo, user)
+	return pbBlack, nil
+}
+
+type DBGroup struct {
+	*imdb.Group
+}
+
+type PBGroup struct {
+	*sdk.GroupInfo
+}
+
+func (pb *PBGroup) convert() (*imdb.Group, error) {
+	dst := &imdb.Group{}
+	utils.CopyStructFields(dst, pb)
+	return dst, nil
+}
+func (db *DBGroup) convert() (*sdk.GroupInfo, error) {
+	dst := &sdk.GroupInfo{}
+	utils.CopyStructFields(dst, db)
+	user, err := getGroupOwnerInfo(db.GroupID)
+	if err != nil {
+		return nil, err
+	}
+	dst.OwnerUserID = user.UserID
+
+	memberCount, err := getNumberOfGroupMember(db.GroupID)
+	if err != nil {
+		return nil, err
+	}
+	dst.MemberCount = uint32(memberCount)
+	dst.CreateTime = uint32(db.CreateTime.Unix())
+	dst.NotificationUpdateTime = uint32(db.NotificationUpdateTime.Unix())
+	if db.NotificationUpdateTime.Unix() < 0 {
+		dst.NotificationUpdateTime = 0
+	}
+	return dst, nil
+}
+
+type DBGroupMember struct {
+	*imdb.GroupMember
+}
+
+type PBGroupMember struct {
+	*sdk.GroupMemberFullInfo
+}
+
+func (pb *PBGroupMember) convert() (*imdb.GroupMember, error) {
+	dst := &imdb.GroupMember{}
+	utils.CopyStructFields(dst, pb)
+	dst.JoinTime = utils.UnixSecondToTime(int64(pb.JoinTime))
+	dst.MuteEndTime = utils.UnixSecondToTime(int64(pb.MuteEndTime))
+	return dst, nil
+}
+func (db *DBGroupMember) convert() (*sdk.GroupMemberFullInfo, error) {
+	dst := &sdk.GroupMemberFullInfo{}
+	utils.CopyStructFields(dst, db)
+
+	user, err := getUsersInfo([]string{db.UserID})
+	if err != nil {
+		return nil, err
+	}
+	dst.AppMangerLevel = user[0].AppMangerLevel
+
+	dst.JoinTime = int32(db.JoinTime.Unix())
+	if db.JoinTime.Unix() < 0 {
+		dst.JoinTime = 0
+	}
+	dst.MuteEndTime = uint32(db.MuteEndTime.Unix())
+	if dst.MuteEndTime < uint32(time.Now().Unix()) {
+		dst.MuteEndTime = 0
+	}
+	return dst, nil
+}
+
+type DBGroupRequest struct {
+	*imdb.GroupRequest
+}
+
+type PBGroupRequest struct {
+	*sdk.GroupRequest
+}
+
+func (pb *PBGroupRequest) convert() (*imdb.GroupRequest, error) {
+	dst := &imdb.GroupRequest{}
+	utils.CopyStructFields(dst, pb)
+	dst.ReqTime = utils.UnixSecondToTime(int64(pb.ReqTime))
+	dst.HandledTime = utils.UnixSecondToTime(int64(pb.HandleTime))
+	return dst, nil
+}
+func (db *DBGroupRequest) convert() (*sdk.GroupRequest, error) {
+	dst := &sdk.GroupRequest{}
+	utils.CopyStructFields(dst, db)
+	dst.ReqTime = uint32(db.ReqTime.Unix())
+	dst.HandleTime = uint32(db.HandledTime.Unix())
+	return dst, nil
+}
+
+func UserOpenIMCopyDB(dst *imdb.User, src *open_im_sdk.UserInfo) {
+	utils.CopyStructFields(dst, src)
+	dst.Birth, _ = utils.TimeStringToTime(src.BirthStr)
+	dst.CreateTime = utils.UnixSecondToTime(int64(src.CreateTime))
+}
+
+func UserDBCopyOpenIM(dst *open_im_sdk.UserInfo, src *imdb.User) {
+	utils.CopyStructFields(dst, src)
+	dst.CreateTime = uint32(src.CreateTime.Unix())
+	//dst.Birth = uint32(src.Birth.Unix())
+	dst.BirthStr = utils2.TimeToString(src.Birth)
+}
+
+func UserDBCopyOpenIMPublicUser(dst *open_im_sdk.PublicUserInfo, src *imdb.User) {
+	utils.CopyStructFields(dst, src)
+}