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

Conflicts: internal/rpc/group/group.go pkg/common/db/relation/user_model_k.go
2026-05-11 12:36:00 +08:00 · 2023-01-30 11:12:35 +08:00
parent 21a1e7dff2 2a76dc3ac8
commit 5b8f66404c
14 changed files with 1313 additions and 1438 deletions
@@ -5,7 +5,7 @@ import (
 	relation "Open_IM/pkg/common/db/mysql"
 	"Open_IM/pkg/common/tools"
 	pbGroup "Open_IM/pkg/proto/group"
-	sdk "Open_IM/pkg/proto/sdk_ws"
+	sdk_ws "Open_IM/pkg/proto/sdk_ws"
 	"Open_IM/pkg/utils"
 	"context"
 	"math/big"
@@ -40,10 +40,22 @@ func getDBGroupMember(ctx context.Context, groupID, userID string) (dbGroupMembe
 	return dbGroupMember, nil
 }

-func getUsersInfo(ctx context.Context, userIDs []string) ([]*sdk.UserInfo, error) {
+func getUsersInfo(ctx context.Context, userIDs []string) ([]*sdk_ws.UserInfo, error) {
 	return nil, nil
 }

+func getUserMap(ctx context.Context, userIDs []string) (map[string]*sdk_ws.UserInfo, error) {
+	users, err := getUsersInfo(ctx, userIDs)
+	if err != nil {
+		return nil, err
+	}
+	userMap := make(map[string]*sdk_ws.UserInfo)
+	for i, user := range users {
+		userMap[user.UserID] = users[i]
+	}
+	return userMap, nil
+}
+
 func genGroupID(ctx context.Context, groupID string) string {
 	if groupID != "" {
 		return groupID
@@ -15,7 +15,6 @@ import (
 	"Open_IM/pkg/common/token_verify"
 	"Open_IM/pkg/common/tools"
 	"Open_IM/pkg/common/trace_log"
-	"Open_IM/pkg/common/tracelog"

 	cp "Open_IM/internal/utils"
 	"Open_IM/pkg/getcdv3"
@@ -26,13 +25,12 @@ import (
 	"Open_IM/pkg/utils"
 	"context"
 	"errors"
+	grpcPrometheus "github.com/grpc-ecosystem/go-grpc-prometheus"
 	"net"
 	"strconv"
 	"strings"
 	"time"

-	grpcPrometheus "github.com/grpc-ecosystem/go-grpc-prometheus"
-
 	"google.golang.org/grpc"
 	"google.golang.org/protobuf/types/known/wrapperspb"
 	"gorm.io/gorm"
@@ -260,139 +258,128 @@ func (s *groupServer) GetJoinedGroupList(ctx context.Context, req *pbGroup.GetJo
 		groupNode.NotificationUpdateTime = group.NotificationUpdateTime.UnixMilli()
 		resp.GroupList = append(resp.GroupList, &groupNode)
 	}
-	resp.Total = uint32(len(resp.GroupList))
+	resp.Total = int32(len(resp.GroupList))
 	return resp, nil
 }

 func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.InviteUserToGroupReq) (*pbGroup.InviteUserToGroupResp, error) {
 	resp := &pbGroup.InviteUserToGroupResp{}
-	opUserID := tools.OpUserID(ctx)
-	if err := token_verify.CheckManagerUserID(ctx, opUserID); err != nil {
-		if err := relation.CheckIsExistGroupMember(ctx, req.GroupID, opUserID); err != nil {
-			return nil, err
-		}
+	if len(req.InvitedUserIDList) == 0 {
+		return nil, constant.ErrArgs.Wrap("user empty")
 	}
-	groupInfo, err := (*relation.Group)(nil).Take(ctx, req.GroupID)
+	if utils.IsDuplicateID(req.InvitedUserIDList) {
+		return nil, constant.ErrArgs.Wrap("userID duplicate")
+	}
+	group, err := s.GroupInterface.TakeGroupByID(ctx, req.GroupID)
 	if err != nil {
 		return nil, err
 	}
-	if groupInfo.Status == constant.GroupStatusDismissed {
-		return nil, utils.Wrap(constant.ErrDismissedAlready, "")
+	if group.Status == constant.GroupStatusDismissed {
+		return nil, constant.ErrDismissedAlready.Wrap()
 	}
-	if groupInfo.NeedVerification == constant.AllNeedVerification &&
-		!relation.IsGroupOwnerAdmin(req.GroupID, tools.OpUserID(ctx)) && !token_verify.IsManagerUserID(tools.OpUserID(ctx)) {
-		joinReq := pbGroup.JoinGroupReq{}
-		for _, v := range req.InvitedUserIDList {
-			var groupRequest relation.GroupRequest
-			groupRequest.UserID = v
-			groupRequest.GroupID = req.GroupID
-			groupRequest.JoinSource = constant.JoinByInvitation
-			groupRequest.InviterUserID = tools.OpUserID(ctx)
-			err = relation.InsertIntoGroupRequest(groupRequest)
-			if err != nil {
-				var resultNode pbGroup.Id2Result
-				resultNode.Result = -1
-				resultNode.UserID = v
-				resp.Id2ResultList = append(resp.Id2ResultList, &resultNode)
-				continue
-			} else {
-				var resultNode pbGroup.Id2Result
-				resultNode.Result = 0
-				resultNode.UserID = v
-				resp.Id2ResultList = append(resp.Id2ResultList, &resultNode)
-				joinReq.GroupID = req.GroupID
-				resp.Id2ResultList = append(resp.Id2ResultList, &resultNode)
-				chat.JoinGroupApplicationNotification(ctx, &joinReq)
-			}
-		}
-		return resp, nil
-	}
-	if err := s.DelGroupAndUserCache(ctx, req.GroupID, req.InvitedUserIDList); err != nil {
+	members, err := s.GroupInterface.GetGroupMemberList(ctx, group.GroupID)
+	if err != nil {
 		return nil, err
 	}
-	//from User:  invite: applicant
-	//to user:  invite: invited
-	var okUserIDList []string
-	if groupInfo.GroupType != constant.SuperGroup {
-		for _, v := range req.InvitedUserIDList {
-			var resultNode pbGroup.Id2Result
-			resultNode.UserID = v
-			resultNode.Result = 0
-			toUserInfo, err := relation.GetUserByUserID(v)
-			if err != nil {
-				tracelog.SetCtxInfo(ctx, "GetUserByUserID", err, "userID", v)
-				resultNode.Result = -1
-				resp.Id2ResultList = append(resp.Id2ResultList, &resultNode)
-				continue
-			}
-
-			if relation.IsExistGroupMember(req.GroupID, v) {
-				tracelog.SetCtxInfo(ctx, "IsExistGroupMember", err, "groupID", req.GroupID, "userID", v)
-				resultNode.Result = -1
-				resp.Id2ResultList = append(resp.Id2ResultList, &resultNode)
-				continue
-			}
-			var toInsertInfo relation.GroupMember
-			utils.CopyStructFields(&toInsertInfo, toUserInfo)
-			toInsertInfo.GroupID = req.GroupID
-			toInsertInfo.RoleLevel = constant.GroupOrdinaryUsers
-			toInsertInfo.OperatorUserID = tools.OpUserID(ctx)
-			toInsertInfo.InviterUserID = tools.OpUserID(ctx)
-			toInsertInfo.JoinSource = constant.JoinByInvitation
-			if err := CallbackBeforeMemberJoinGroup(ctx, tools.OperationID(ctx), &toInsertInfo, groupInfo.Ex); err != nil {
-				return nil, err
-			}
-			err = relation.InsertIntoGroupMember(toInsertInfo)
-			if err != nil {
-				tracelog.SetCtxInfo(ctx, "InsertIntoGroupMember", err, "args", toInsertInfo)
-				resultNode.Result = -1
-				resp.Id2ResultList = append(resp.Id2ResultList, &resultNode)
-				continue
-			}
-			okUserIDList = append(okUserIDList, v)
-			err = db.DB.AddGroupMember(req.GroupID, toUserInfo.UserID)
-			if err != nil {
-				tracelog.SetCtxInfo(ctx, "AddGroupMember", err, "groupID", req.GroupID, "userID", toUserInfo.UserID)
-			}
-			resp.Id2ResultList = append(resp.Id2ResultList, &resultNode)
-		}
-	} else {
-		okUserIDList = req.InvitedUserIDList
-		if err := db.DB.AddUserToSuperGroup(req.GroupID, req.InvitedUserIDList); err != nil {
-			return nil, err
+	memberMap := make(map[string]*relation.GroupMember)
+	for i, member := range members {
+		memberMap[member.GroupID] = members[i]
+	}
+	for _, userID := range req.InvitedUserIDList {
+		if _, ok := memberMap[userID]; ok {
+			return nil, constant.ErrArgs.Wrap("user in group " + userID)
 		}
 	}
-
-	if groupInfo.GroupType != constant.SuperGroup {
-		chat.MemberInvitedNotification(tools.OperationID(ctx), req.GroupID, tools.OpUserID(ctx), req.Reason, okUserIDList)
-	} else {
-		for _, userID := range req.InvitedUserIDList {
-			if err := rocksCache.DelJoinedSuperGroupIDListFromCache(ctx, userID); err != nil {
-				tracelog.SetCtxInfo(ctx, "DelJoinedSuperGroupIDListFromCache", err, "userID", userID)
+	userMap, err := getUserMap(ctx, req.InvitedUserIDList)
+	if err != nil {
+		return nil, err
+	}
+	for _, userID := range req.InvitedUserIDList {
+		if _, ok := userMap[userID]; !ok {
+			return nil, constant.ErrUserIDNotFound.Wrap(userID)
+		}
+	}
+	if group.NeedVerification == constant.AllNeedVerification {
+		if !token_verify.IsAppManagerUid(ctx) {
+			opUserID := tools.OpUserID(ctx)
+			member, ok := memberMap[opUserID]
+			if ok {
+				return nil, constant.ErrNoPermission.Wrap("not in group")
+			}
+			if !(member.RoleLevel == constant.GroupOwner || member.RoleLevel == constant.GroupAdmin) {
+				var requests []*relation.GroupRequest
+				for _, userID := range req.InvitedUserIDList {
+					requests = append(requests, &relation.GroupRequest{
+						UserID:        userID,
+						GroupID:       req.GroupID,
+						JoinSource:    constant.JoinByInvitation,
+						InviterUserID: opUserID,
+					})
+				}
+				if err := s.GroupInterface.CreateGroupRequest(ctx, requests); err != nil {
+					return nil, err
+				}
+				for _, request := range requests {
+					chat.JoinGroupApplicationNotification(ctx, &pbGroup.JoinGroupReq{
+						GroupID:       request.GroupID,
+						ReqMessage:    request.ReqMsg,
+						JoinSource:    request.JoinSource,
+						InviterUserID: request.InviterUserID,
+					})
+				}
+				return resp, nil
 			}
 		}
-		for _, v := range req.InvitedUserIDList {
-			chat.SuperGroupNotification(tools.OperationID(ctx), v, v)
+	}
+	if group.GroupType == constant.SuperGroup {
+		if err := s.GroupInterface.AddUserToSuperGroup(ctx, req.GroupID, req.InvitedUserIDList); err != nil {
+			return nil, err
 		}
+		for _, userID := range req.InvitedUserIDList {
+			chat.SuperGroupNotification(tools.OperationID(ctx), userID, userID)
+		}
+	} else {
+		var groupMembers []*relation.GroupMember
+		for _, userID := range req.InvitedUserIDList {
+			user := userMap[userID]
+			var member relation.GroupMember
+			utils.CopyStructFields(&member, user)
+			member.GroupID = req.GroupID
+			member.RoleLevel = constant.GroupOrdinaryUsers
+			member.OperatorUserID = tools.OpUserID(ctx)
+			member.InviterUserID = tools.OpUserID(ctx)
+			member.JoinSource = constant.JoinByInvitation
+			if err := CallbackBeforeMemberJoinGroup(ctx, tools.OperationID(ctx), &member, group.Ex); err != nil {
+				return nil, err
+			}
+			groupMembers = append(groupMembers, &member)
+		}
+		if err := s.GroupInterface.CreateGroupMember(ctx, groupMembers); err != nil {
+			return nil, err
+		}
+		chat.MemberInvitedNotification(tools.OperationID(ctx), req.GroupID, tools.OpUserID(ctx), req.Reason, req.InvitedUserIDList)
 	}
 	return resp, nil
 }

 func (s *groupServer) GetGroupAllMember(ctx context.Context, req *pbGroup.GetGroupAllMemberReq) (*pbGroup.GetGroupAllMemberResp, error) {
 	resp := &pbGroup.GetGroupAllMemberResp{}
-
-	groupInfo, err := rocksCache.GetGroupInfoFromCache(ctx, req.GroupID)
+	group, err := s.GroupInterface.TakeGroupByID(ctx, req.GroupID)
 	if err != nil {
 		return nil, err
 	}
-	if groupInfo.GroupType != constant.SuperGroup {
-		memberList, err := rocksCache.GetGroupMembersInfoFromCache(ctx, req.Count, req.Offset, req.GroupID)
+	if group.GroupType != constant.SuperGroup {
+		members, err := s.GroupInterface.GetGroupMemberList(ctx, req.GroupID)
 		if err != nil {
 			return nil, err
 		}
-		for _, v := range memberList {
+		var userIDs []string
+		for _, member := range members {
+			userIDs = append(userIDs, member.UserID)
+		}
+		for _, member := range members {
 			var node open_im_sdk.GroupMemberFullInfo
-			cp.GroupMemberDBCopyOpenIM(&node, v)
+			utils.CopyStructFields(&node, member)
 			resp.MemberList = append(resp.MemberList, &node)
 		}
 	}
@@ -401,12 +388,10 @@ func (s *groupServer) GetGroupAllMember(ctx context.Context, req *pbGroup.GetGro

 func (s *groupServer) GetGroupMemberList(ctx context.Context, req *pbGroup.GetGroupMemberListReq) (*pbGroup.GetGroupMemberListResp, error) {
 	resp := &pbGroup.GetGroupMemberListResp{}
-
-	memberList, err := relation.GetGroupMemberByGroupID(req.GroupID, req.Filter, req.NextSeq, 30)
+	memberList, err := s.GroupInterface.GetGroupMemberFilterList(ctx, req.GroupID, req.Filter, req.NextSeq, 30)
 	if err != nil {
 		return nil, err
 	}
-
 	for _, v := range memberList {
 		var node open_im_sdk.GroupMemberFullInfo
 		utils.CopyStructFields(&node, &v)
@@ -481,23 +466,23 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
 			kickedInfo, err := rocksCache.GetGroupMemberInfoFromCache(ctx, req.GroupID, v)
 			if err != nil {
 				resp.Id2ResultList = append(resp.Id2ResultList, &pbGroup.Id2Result{UserID: v, Result: -1})
-				tracelog.SetCtxInfo(ctx, "GetGroupMemberInfoFromCache", err, "groupID", req.GroupID, "userID", v)
+				trace_log.SetCtxInfo(ctx, "GetGroupMemberInfoFromCache", err, "groupID", req.GroupID, "userID", v)
 				continue
 			}

 			if kickedInfo.RoleLevel == constant.GroupAdmin && opFlag == 3 {
 				resp.Id2ResultList = append(resp.Id2ResultList, &pbGroup.Id2Result{UserID: v, Result: -1})
-				tracelog.SetCtxInfo(ctx, "", nil, "msg", "is constant.GroupAdmin, can't kicked", "groupID", req.GroupID, "userID", v)
+				trace_log.SetCtxInfo(ctx, "", nil, "msg", "is constant.GroupAdmin, can't kicked", "groupID", req.GroupID, "userID", v)
 				continue
 			}
 			if kickedInfo.RoleLevel == constant.GroupOwner && opFlag != 1 {
 				resp.Id2ResultList = append(resp.Id2ResultList, &pbGroup.Id2Result{UserID: v, Result: -1})
-				tracelog.SetCtxInfo(ctx, "", nil, "msg", "is constant.GroupOwner, can't kicked", "groupID", req.GroupID, "userID", v)
+				trace_log.SetCtxInfo(ctx, "", nil, "msg", "is constant.GroupOwner, can't kicked", "groupID", req.GroupID, "userID", v)
 				continue
 			}

 			err = relation.DeleteGroupMemberByGroupIDAndUserID(req.GroupID, v)
-			tracelog.SetCtxInfo(ctx, "RemoveGroupMember", err, "groupID", req.GroupID, "userID", v)
+			trace_log.SetCtxInfo(ctx, "RemoveGroupMember", err, "groupID", req.GroupID, "userID", v)
 			if err != nil {
 				log.NewError(tools.OperationID(ctx), "RemoveGroupMember failed ", err.Error(), req.GroupID, v)
 				resp.Id2ResultList = append(resp.Id2ResultList, &pbGroup.Id2Result{UserID: v, Result: -1})
@@ -522,7 +507,7 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
 			}
 			client := pbUser.NewUserClient(etcdConn)
 			respPb, err := client.SetConversation(context.Background(), &reqPb)
-			tracelog.SetCtxInfo(ctx, "SetConversation", err, "req", &reqPb, "resp", respPb)
+			trace_log.SetCtxInfo(ctx, "SetConversation", err, "req", &reqPb, "resp", respPb)
 		}
 	} else {
 		okUserIDList = req.KickedUserIDList
@@ -534,14 +519,14 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
 	if groupInfo.GroupType != constant.SuperGroup {
 		for _, userID := range okUserIDList {
 			if err := rocksCache.DelGroupMemberInfoFromCache(ctx, req.GroupID, userID); err != nil {
-				tracelog.SetCtxInfo(ctx, "DelGroupMemberInfoFromCache", err, "groupID", req.GroupID, "userID", userID)
+				trace_log.SetCtxInfo(ctx, "DelGroupMemberInfoFromCache", err, "groupID", req.GroupID, "userID", userID)
 			}
 		}
 		chat.MemberKickedNotification(req, okUserIDList)
 	} else {
 		for _, userID := range okUserIDList {
 			if err = rocksCache.DelJoinedSuperGroupIDListFromCache(ctx, userID); err != nil {
-				tracelog.SetCtxInfo(ctx, "DelGroupMemberInfoFromCache", err, "userID", userID)
+				trace_log.SetCtxInfo(ctx, "DelGroupMemberInfoFromCache", err, "userID", userID)
 			}
 		}
 		go func() {
@@ -556,15 +541,14 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou

 func (s *groupServer) GetGroupMembersInfo(ctx context.Context, req *pbGroup.GetGroupMembersInfoReq) (*pbGroup.GetGroupMembersInfoResp, error) {
 	resp := &pbGroup.GetGroupMembersInfoResp{}
-	resp.MemberList = []*open_im_sdk.GroupMemberFullInfo{}
-	for _, userID := range req.MemberList {
-		groupMember, err := rocksCache.GetGroupMemberInfoFromCache(ctx, req.GroupID, userID)
-		if err != nil {
-			return nil, err
-		}
+	members, err := s.GroupInterface.GetGroupMemberListByUserID(ctx, req.GroupID, req.MemberList)
+	if err != nil {
+		return nil, err
+	}
+	for _, member := range members {
 		var memberNode open_im_sdk.GroupMemberFullInfo
-		utils.CopyStructFields(&memberNode, groupMember)
-		memberNode.JoinTime = int32(groupMember.JoinTime.Unix())
+		utils.CopyStructFields(&memberNode, member)
+		memberNode.JoinTime = member.JoinTime.UnixMilli()
 		resp.MemberList = append(resp.MemberList, &memberNode)
 	}
 	return resp, nil
@@ -600,7 +584,7 @@ func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup.
 		return nil, err
 	}
 	var errResult error
-	tracelog.SetCtxInfo(ctx, "GetRecvGroupApplicationList", nil, " FromUserID: ", req.FromUserID, "GroupApplicationList: ", reply)
+	trace_log.SetCtxInfo(ctx, "GetRecvGroupApplicationList", nil, " FromUserID: ", req.FromUserID, "GroupApplicationList: ", reply)
 	for _, v := range reply {
 		node := open_im_sdk.GroupRequest{UserInfo: &open_im_sdk.PublicUserInfo{}, GroupInfo: &open_im_sdk.GroupInfo{}}
 		err := FillGroupInfoByGroupID(tools.OperationID(ctx), v.GroupID, node.GroupInfo)
@@ -610,7 +594,7 @@ func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup.
 			}
 			continue
 		}
-		tracelog.SetCtxInfo(ctx, "FillGroupInfoByGroupID ", nil, " groupID: ", v.GroupID, " groupInfo: ", node.GroupInfo)
+		trace_log.SetCtxInfo(ctx, "FillGroupInfoByGroupID ", nil, " groupID: ", v.GroupID, " groupInfo: ", node.GroupInfo)
 		err = FillPublicUserInfoByUserID(tools.OperationID(ctx), v.UserID, node.UserInfo)
 		if err != nil {
 			errResult = err
@@ -622,7 +606,7 @@ func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup.
 	if errResult != nil && len(resp.GroupRequestList) == 0 {
 		return nil, err
 	}
-	tracelog.SetRpcRespInfo(ctx, utils.GetSelfFuncName(), resp.String())
+	trace_log.SetRpcRespInfo(ctx, utils.GetSelfFuncName(), resp.String())
 	return resp, nil
 }

@@ -645,7 +629,7 @@ func (s *groupServer) GetGroupsInfo(ctx context.Context, req *pbGroup.GetGroupsI

 func CheckPermission(ctx context.Context, groupID string, userID string) (err error) {
 	defer func() {
-		tracelog.SetCtxInfo(ctx, utils.GetSelfFuncName(), err, "groupID", groupID, "userID", userID)
+		trace_log.SetCtxInfo(ctx, utils.GetSelfFuncName(), err, "groupID", groupID, "userID", userID)
 	}()
 	if !token_verify.IsManagerUserID(userID) && !relation.IsGroupOwnerAdmin(groupID, userID) {
 		return utils.Wrap(constant.ErrNoPermission, utils.GetSelfFuncName())
@@ -765,7 +749,7 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
 			}
 			client := pbUser.NewUserClient(etcdConn)
 			respPb, err := client.SetConversation(context.Background(), &reqPb)
-			tracelog.SetCtxInfo(ctx, "SetConversation", err, "req", reqPb, "resp", respPb)
+			trace_log.SetCtxInfo(ctx, "SetConversation", err, "req", reqPb, "resp", respPb)
 			chat.MemberEnterDirectlyNotification(req.GroupID, tools.OpUserID(ctx), tools.OperationID(ctx))
 			return resp, nil
 		} else {
@@ -933,7 +917,7 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
 		}
 		nClient := pbConversation.NewConversationClient(nEtcdConn)
 		conversationReply, err := nClient.ModifyConversationField(context.Background(), &conversationReq)
-		tracelog.SetCtxInfo(ctx, "ModifyConversationField", err, "req", &conversationReq, "resp", conversationReply)
+		trace_log.SetCtxInfo(ctx, "ModifyConversationField", err, "req", &conversationReq, "resp", conversationReply)
 	}
 	return resp, nil
 }
@@ -1006,14 +990,14 @@ func (s *groupServer) GetGroups(ctx context.Context, req *pbGroup.GetGroupsReq)
 	} else {
 		groups, count, err := relation.GetGroupsByName(req.GroupName, req.Pagination.PageNumber, req.Pagination.ShowNumber)
 		if err != nil {
-			tracelog.SetCtxInfo(ctx, "GetGroupsByName", err, "GroupName", req.GroupName, "PageNumber", req.Pagination.PageNumber, "ShowNumber", req.Pagination.ShowNumber)
+			trace_log.SetCtxInfo(ctx, "GetGroupsByName", err, "GroupName", req.GroupName, "PageNumber", req.Pagination.PageNumber, "ShowNumber", req.Pagination.ShowNumber)
 		}
 		for _, v := range groups {
 			group := &pbGroup.CMSGroup{GroupInfo: &open_im_sdk.GroupInfo{}}
 			utils.CopyStructFields(group.GroupInfo, v)
 			groupMember, err := relation.GetGroupOwnerInfoByGroupID(v.GroupID)
 			if err != nil {
-				tracelog.SetCtxInfo(ctx, "GetGroupOwnerInfoByGroupID", err, "GroupID", v.GroupID)
+				trace_log.SetCtxInfo(ctx, "GetGroupOwnerInfoByGroupID", err, "GroupID", v.GroupID)
 				continue
 			}
 			group.GroupInfo.CreateTime = uint32(v.CreateTime.Unix())
@@ -1062,12 +1046,12 @@ func (s *groupServer) GetUserReqApplicationList(ctx context.Context, req *pbGrou
 		node := open_im_sdk.GroupRequest{UserInfo: &open_im_sdk.PublicUserInfo{}, GroupInfo: &open_im_sdk.GroupInfo{}}
 		group, err := relation.GetGroupInfoByGroupID(groupReq.GroupID)
 		if err != nil {
-			tracelog.SetCtxInfo(ctx, "GetGroupInfoByGroupID", err, "GroupID", groupReq.GroupID)
+			trace_log.SetCtxInfo(ctx, "GetGroupInfoByGroupID", err, "GroupID", groupReq.GroupID)
 			continue
 		}
 		user, err := relation.GetUserByUserID(groupReq.UserID)
 		if err != nil {
-			tracelog.SetCtxInfo(ctx, "GetUserByUserID", err, "UserID", groupReq.UserID)
+			trace_log.SetCtxInfo(ctx, "GetUserByUserID", err, "UserID", groupReq.UserID)
 			continue
 		}
 		cp.GroupRequestDBCopyOpenIM(&node, &groupReq)
@@ -1103,7 +1087,7 @@ func (s *groupServer) DismissGroup(ctx context.Context, req *pbGroup.DismissGrou
 	if groupInfo.GroupType != constant.SuperGroup {
 		memberList, err := relation.GetGroupMemberListByGroupID(req.GroupID)
 		if err != nil {
-			tracelog.SetCtxInfo(ctx, "GetGroupMemberListByGroupID", err, "groupID", req.GroupID)
+			trace_log.SetCtxInfo(ctx, "GetGroupMemberListByGroupID", err, "groupID", req.GroupID)
 		}
 		//modify quitter conversation info
 		var reqPb pbUser.SetConversationReq
@@ -1119,7 +1103,7 @@ func (s *groupServer) DismissGroup(ctx context.Context, req *pbGroup.DismissGrou
 			etcdConn, err := getcdv3.GetConn(ctx, config.Config.RpcRegisterName.OpenImUserName)
 			client := pbUser.NewUserClient(etcdConn)
 			respPb, err := client.SetConversation(context.Background(), &reqPb)
-			tracelog.SetCtxInfo(ctx, "SetConversation", err, "req", &reqPb, "resp", respPb)
+			trace_log.SetCtxInfo(ctx, "SetConversation", err, "req", &reqPb, "resp", respPb)
 		}
 		err = relation.DeleteGroupMemberByGroupID(req.GroupID)
 		if err != nil {
@@ -1382,7 +1366,7 @@ func (s *groupServer) GetGroupAbstractInfo(ctx context.Context, req *pbGroup.Get
 }

 func (s *groupServer) DelGroupAndUserCache(ctx context.Context, groupID string, userIDList []string) error {
-	operationID := tracelog.GetOperationID(ctx)
+	operationID := trace_log.GetOperationID(ctx)
 	if groupID != "" {
 		etcdConn, err := getcdv3.GetConn(ctx, config.Config.RpcRegisterName.OpenImCacheName)
 		if err != nil {
@@ -25,13 +25,13 @@ func getFromToUserNickname(fromUserID, toUserID string) (string, string, error)
 	return from.Nickname, to.Nickname, nil
 }

-func friendNotification(commID *pbFriend.CommID, contentType int32, m proto.Message) {
-	log.Info(commID.OperationID, utils.GetSelfFuncName(), "args: ", commID, contentType)
+func friendNotification(operationID, fromUserID, toUserID string, contentType int32, m proto.Message) {
+	log.Info(operationID, utils.GetSelfFuncName(), "args: ", commID, contentType)
 	var err error
 	var tips open_im_sdk.TipsComm
 	tips.Detail, err = proto.Marshal(m)
 	if err != nil {
-		log.Error(commID.OperationID, "Marshal failed ", err.Error(), m.String())
+		log.Error(operationID, "Marshal failed ", err.Error(), m.String())
 		return
 	}

@@ -43,9 +43,9 @@ func friendNotification(commID *pbFriend.CommID, contentType int32, m proto.Mess

 	tips.JsonDetail, _ = marshaler.MarshalToString(m)

-	fromUserNickname, toUserNickname, err := getFromToUserNickname(commID.FromUserID, commID.ToUserID)
+	fromUserNickname, toUserNickname, err := getFromToUserNickname(fromUserID, toUserID)
 	if err != nil {
-		log.Error(commID.OperationID, "getFromToUserNickname failed ", err.Error(), commID.FromUserID, commID.ToUserID)
+		log.Error(operationID, "getFromToUserNickname failed ", err.Error(), fromUserID, toUserID)
 		return
 	}
 	cn := config.Config.Notification
@@ -71,20 +71,20 @@ func friendNotification(commID *pbFriend.CommID, contentType int32, m proto.Mess
 	case constant.FriendInfoUpdatedNotification:
 		tips.DefaultTips = cn.FriendInfoUpdated.DefaultTips.Tips + toUserNickname
 	default:
-		log.Error(commID.OperationID, "contentType failed ", contentType)
+		log.Error(operationID, "contentType failed ", contentType)
 		return
 	}

 	var n NotificationMsg
-	n.SendID = commID.FromUserID
-	n.RecvID = commID.ToUserID
+	n.SendID = fromUserID
+	n.RecvID = toUserID
 	n.ContentType = contentType
 	n.SessionType = constant.SingleChatType
 	n.MsgFrom = constant.SysMsgType
-	n.OperationID = commID.OperationID
+	n.OperationID = operationID
 	n.Content, err = proto.Marshal(&tips)
 	if err != nil {
-		log.Error(commID.OperationID, "Marshal failed ", err.Error(), tips.String())
+		log.Error(operationID, "Marshal failed ", err.Error(), tips.String())
 		return
 	}
 	Notification(&n)
@@ -160,7 +160,7 @@ func BlackDeletedNotification(req *pbFriend.RemoveBlacklistReq) {
 	friendNotification(req.CommID, constant.BlackDeletedNotification, &blackDeletedTips)
 }

-//send to myself
+// send to myself
 func UserInfoUpdatedNotification(operationID, opUserID string, changedUserID string) {
 	selfInfoUpdatedTips := open_im_sdk.UserInfoUpdatedTips{UserID: changedUserID}
 	commID := pbFriend.CommID{FromUserID: opUserID, ToUserID: changedUserID, OpUserID: opUserID, OperationID: operationID}
@@ -169,6 +169,5 @@ func UserInfoUpdatedNotification(operationID, opUserID string, changedUserID str

 func FriendInfoUpdatedNotification(operationID, changedUserID string, needNotifiedUserID string, opUserID string) {
 	selfInfoUpdatedTips := open_im_sdk.UserInfoUpdatedTips{UserID: changedUserID}
-	commID := pbFriend.CommID{FromUserID: opUserID, ToUserID: needNotifiedUserID, OpUserID: opUserID, OperationID: operationID}
-	friendNotification(&commID, constant.FriendInfoUpdatedNotification, &selfInfoUpdatedTips)
+	friendNotification(operationID, opUserID, needNotifiedUserID, constant.FriendInfoUpdatedNotification, &selfInfoUpdatedTips)
 }
@@ -11,13 +11,12 @@ import (
 	"Open_IM/pkg/common/token_verify"
 	"Open_IM/pkg/common/tools"
 	"Open_IM/pkg/getcdv3"
-	pbConversation "Open_IM/pkg/proto/conversation"
 	pbFriend "Open_IM/pkg/proto/friend"
-	sdkws "Open_IM/pkg/proto/sdk_ws"
+	pbGroup "Open_IM/pkg/proto/group"
 	pbUser "Open_IM/pkg/proto/user"
 	"Open_IM/pkg/utils"
 	"context"
-	"errors"
+	"github.com/golang/protobuf/ptypes/wrappers"
 	"net"
 	"strconv"
 	"strings"
@@ -26,7 +25,6 @@ import (

 	utils2 "Open_IM/internal/utils"
 	"google.golang.org/grpc"
-	"gorm.io/gorm"
 )

 type userServer struct {
@@ -62,7 +60,7 @@ func NewUserServer(port int) *userServer {
 }

 func (s *userServer) Run() {
-	log.NewInfo("0", "rpc user start...")
+	log.NewInfo("", "rpc user start...")

 	listenIP := ""
 	if config.Config.ListenIP == "" {
@@ -77,7 +75,7 @@ func (s *userServer) Run() {
 	if err != nil {
 		panic("listening err:" + err.Error() + s.rpcRegisterName)
 	}
-	log.NewInfo("0", "listen network success, address ", address, listener)
+	log.NewInfo("", "listen network success, address ", address, listener)
 	defer listener.Close()
 	//grpc server
 	var grpcOpts []grpc.ServerOption
@@ -102,327 +100,70 @@ func (s *userServer) Run() {
 			log.Error("", "GetLocalIP failed ", err.Error())
 		}
 	}
-	err = getcdv3.RegisterEtcd(s.etcdSchema, strings.Join(s.etcdAddr, ","), rpcRegisterIP, s.rpcPort, s.rpcRegisterName, 10)
+	err = getcdv3.RegisterEtcd(s.etcdSchema, strings.Join(s.etcdAddr, ","), rpcRegisterIP, s.rpcPort, s.rpcRegisterName, 10, "")
 	if err != nil {
-		log.NewError("0", "RegisterEtcd failed ", err.Error(), s.etcdSchema, strings.Join(s.etcdAddr, ","), rpcRegisterIP, s.rpcPort, s.rpcRegisterName)
+		log.NewError("", "RegisterEtcd failed ", err.Error(), s.etcdSchema, strings.Join(s.etcdAddr, ","), rpcRegisterIP, s.rpcPort, s.rpcRegisterName)
 		panic(utils.Wrap(err, "register user module  rpc to etcd err"))
 	}
 	err = srv.Serve(listener)
 	if err != nil {
-		log.NewError("0", "Serve failed ", err.Error())
+		log.NewError("", "Serve failed ", err.Error())
 		return
 	}
-	log.NewInfo("0", "rpc  user success")
+	log.NewInfo("", "rpc  user success")
 }

-func syncPeerUserConversation(conversation *pbConversation.Conversation, operationID string) error {
-	peerUserConversation := imdb.Conversation{
-		OwnerUserID:      conversation.UserID,
-		ConversationID:   utils.GetConversationIDBySessionType(conversation.OwnerUserID, constant.SingleChatType),
-		ConversationType: constant.SingleChatType,
-		UserID:           conversation.OwnerUserID,
-		GroupID:          "",
-		RecvMsgOpt:       0,
-		UnreadCount:      0,
-		DraftTextTime:    0,
-		IsPinned:         false,
-		IsPrivateChat:    conversation.IsPrivateChat,
-		AttachedInfo:     "",
-		Ex:               "",
-	}
-	err := imdb.PeerUserSetConversation(peerUserConversation)
+func (s *userServer) SyncJoinedGroupMemberFaceURL(ctx context.Context, userID string, faceURL string, operationID string, opUserID string) {
+	etcdConn, err := getcdv3.GetConn(ctx, config.Config.RpcRegisterName.OpenImFriendName)
 	if err != nil {
-		log.NewError(operationID, utils.GetSelfFuncName(), "SetConversation error", err.Error())
-		return err
-	}
-	chat.ConversationSetPrivateNotification(operationID, conversation.OwnerUserID, conversation.UserID, conversation.IsPrivateChat)
-	return nil
-}
-
-func (s *userServer) BatchSetConversations(ctx context.Context, req *pbUser.BatchSetConversationsReq) (*pbUser.BatchSetConversationsResp, error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
-	if req.NotificationType == 0 {
-		req.NotificationType = constant.ConversationOptChangeNotification
-	}
-	resp := &pbUser.BatchSetConversationsResp{}
-	for _, v := range req.Conversations {
-		conversation := imdb.Conversation{}
-		if err := utils.CopyStructFields(&conversation, v); err != nil {
-			log.NewDebug(req.OperationID, utils.GetSelfFuncName(), v.String(), "CopyStructFields failed", err.Error())
-		}
-		//redis op
-		if err := db.DB.SetSingleConversationRecvMsgOpt(req.OwnerUserID, v.ConversationID, v.RecvMsgOpt); err != nil {
-			log.NewError(req.OperationID, utils.GetSelfFuncName(), "cache failed, rpc return", err.Error())
-			resp.CommonResp = &pbUser.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
-			return resp, nil
-		}
-
-		isUpdate, err := imdb.SetConversation(conversation)
-		if err != nil {
-			log.NewError(req.OperationID, utils.GetSelfFuncName(), "SetConversation error", err.Error())
-			resp.Failed = append(resp.Failed, v.ConversationID)
-			continue
-		}
-		if isUpdate {
-			err = rocksCache.DelConversationFromCache(v.OwnerUserID, v.ConversationID)
-		} else {
-			err = rocksCache.DelUserConversationIDListFromCache(v.OwnerUserID)
-		}
-		if err != nil {
-			log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), v.ConversationID, v.OwnerUserID)
-		}
-		resp.Success = append(resp.Success, v.ConversationID)
-		// if is set private msg operation，then peer user need to sync and set tips\
-		if v.ConversationType == constant.SingleChatType && req.NotificationType == constant.ConversationPrivateChatNotification {
-			if err := syncPeerUserConversation(v, req.OperationID); err != nil {
-				log.NewError(req.OperationID, utils.GetSelfFuncName(), "syncPeerUserConversation", err.Error())
-			}
-		}
-	}
-	chat.ConversationChangeNotification(req.OperationID, req.OwnerUserID)
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc return", resp.String())
-	resp.CommonResp = &pbUser.CommonResp{}
-	return resp, nil
-}
-
-func (s *userServer) GetAllConversations(ctx context.Context, req *pbUser.GetAllConversationsReq) (*pbUser.GetAllConversationsResp, error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
-	resp := &pbUser.GetAllConversationsResp{Conversations: []*pbConversation.Conversation{}}
-	conversations, err := rocksCache.GetUserAllConversationList(req.OwnerUserID)
-	log.NewDebug(req.OperationID, "conversations: ", conversations)
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetConversations error", err.Error())
-		resp.CommonResp = &pbUser.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
-		return resp, nil
-	}
-	if err = utils.CopyStructFields(&resp.Conversations, conversations); err != nil {
-		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields error", err.Error())
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc return", resp.String())
-	resp.CommonResp = &pbUser.CommonResp{}
-	return resp, nil
-}
-
-func (s *userServer) GetConversation(ctx context.Context, req *pbUser.GetConversationReq) (*pbUser.GetConversationResp, error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
-	resp := &pbUser.GetConversationResp{Conversation: &pbConversation.Conversation{}}
-	conversation, err := rocksCache.GetConversationFromCache(req.OwnerUserID, req.ConversationID)
-	log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "conversation", conversation)
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetConversation error", err.Error())
-		resp.CommonResp = &pbUser.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
-		return resp, nil
-	}
-	if err := utils.CopyStructFields(resp.Conversation, &conversation); err != nil {
-		log.Debug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields error", conversation, err.Error())
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
-	resp.CommonResp = &pbUser.CommonResp{}
-	return resp, nil
-}
-
-func (s *userServer) GetConversations(ctx context.Context, req *pbUser.GetConversationsReq) (*pbUser.GetConversationsResp, error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
-	resp := &pbUser.GetConversationsResp{Conversations: []*pbConversation.Conversation{}}
-	conversations, err := rocksCache.GetConversationsFromCache(req.OwnerUserID, req.ConversationIDs)
-	log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "conversations", conversations)
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetConversations error", err.Error())
-		resp.CommonResp = &pbUser.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
-		return resp, nil
-	}
-	if err := utils.CopyStructFields(&resp.Conversations, conversations); err != nil {
-		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", conversations, err.Error())
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
-	resp.CommonResp = &pbUser.CommonResp{}
-	return resp, nil
-}
-
-func (s *userServer) SetConversation(ctx context.Context, req *pbUser.SetConversationReq) (*pbUser.SetConversationResp, error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
-	resp := &pbUser.SetConversationResp{}
-	if req.NotificationType == 0 {
-		req.NotificationType = constant.ConversationOptChangeNotification
-	}
-	if req.Conversation.ConversationType == constant.GroupChatType {
-		groupInfo, err := imdb.GetGroupInfoByGroupID(req.Conversation.GroupID)
-		if err != nil {
-			log.NewError(req.OperationID, "GetGroupInfoByGroupID failed ", req.Conversation.GroupID, err.Error())
-			resp.CommonResp = &pbUser.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
-			return resp, nil
-		}
-		if groupInfo.Status == constant.GroupStatusDismissed && !req.Conversation.IsNotInGroup {
-			log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "group status is dismissed", groupInfo)
-			errMsg := "group status is dismissed"
-			resp.CommonResp = &pbUser.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}
-			return resp, nil
-		}
-	}
-	var conversation imdb.Conversation
-	if err := utils.CopyStructFields(&conversation, req.Conversation); err != nil {
-		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", *req.Conversation, err.Error())
-	}
-	if err := db.DB.SetSingleConversationRecvMsgOpt(req.Conversation.OwnerUserID, req.Conversation.ConversationID, req.Conversation.RecvMsgOpt); err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "cache failed, rpc return", err.Error())
-		resp.CommonResp = &pbUser.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
-		return resp, nil
-	}
-	isUpdate, err := imdb.SetConversation(conversation)
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "SetConversation error", err.Error())
-		resp.CommonResp = &pbUser.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
-		return resp, nil
-	}
-	if isUpdate {
-		err = rocksCache.DelConversationFromCache(req.Conversation.OwnerUserID, req.Conversation.ConversationID)
-	} else {
-		err = rocksCache.DelUserConversationIDListFromCache(req.Conversation.OwnerUserID)
-	}
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.Conversation.ConversationID, req.Conversation.OwnerUserID)
-	}
-
-	// notification
-	if req.Conversation.ConversationType == constant.SingleChatType && req.NotificationType == constant.ConversationPrivateChatNotification {
-		//sync peer user conversation if conversation is singleChatType
-		if err := syncPeerUserConversation(req.Conversation, req.OperationID); err != nil {
-			log.NewError(req.OperationID, utils.GetSelfFuncName(), "syncPeerUserConversation", err.Error())
-			resp.CommonResp = &pbUser.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
-			return resp, nil
-		}
-	} else {
-		chat.ConversationChangeNotification(req.OperationID, req.Conversation.OwnerUserID)
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc return", resp.String())
-	resp.CommonResp = &pbUser.CommonResp{}
-	return resp, nil
-}
-
-func (s *userServer) SetRecvMsgOpt(ctx context.Context, req *pbUser.SetRecvMsgOptReq) (*pbUser.SetRecvMsgOptResp, error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
-	resp := &pbUser.SetRecvMsgOptResp{}
-	var conversation imdb.Conversation
-	if err := utils.CopyStructFields(&conversation, req); err != nil {
-		log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "CopyStructFields failed", *req, err.Error())
-	}
-	if err := db.DB.SetSingleConversationRecvMsgOpt(req.OwnerUserID, req.ConversationID, req.RecvMsgOpt); err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "cache failed, rpc return", err.Error())
-		resp.CommonResp = &pbUser.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
-		return resp, nil
-	}
-	stringList := strings.Split(req.ConversationID, "_")
-	if len(stringList) > 1 {
-		switch stringList[0] {
-		case "single":
-			conversation.UserID = stringList[1]
-			conversation.ConversationType = constant.SingleChatType
-		case "group":
-			conversation.GroupID = stringList[1]
-			conversation.ConversationType = constant.GroupChatType
-		}
-	}
-	isUpdate, err := imdb.SetRecvMsgOpt(conversation)
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "SetConversation error", err.Error())
-		resp.CommonResp = &pbUser.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}
-		return resp, nil
-	}
-	if isUpdate {
-		err = rocksCache.DelConversationFromCache(conversation.OwnerUserID, conversation.ConversationID)
-	} else {
-		err = rocksCache.DelUserConversationIDListFromCache(conversation.OwnerUserID)
-	}
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), conversation.ConversationID, err.Error())
-	}
-	chat.ConversationChangeNotification(req.OperationID, req.OwnerUserID)
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
-	resp.CommonResp = &pbUser.CommonResp{}
-	return resp, nil
-}
-
-func (s *userServer) GetAllUserID(_ context.Context, req *pbUser.GetAllUserIDReq) (*pbUser.GetAllUserIDResp, error) {
-	log.NewInfo(req.OperationID, "GetAllUserID args ", req.String())
-	if !token_verify.IsManagerUserID(req.OpUserID) {
-		log.NewError(req.OperationID, "IsManagerUserID false ", req.OpUserID)
-		return &pbUser.GetAllUserIDResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
-	}
-	uidList, err := imdb.SelectAllUserID()
-	if err != nil {
-		log.NewError(req.OperationID, "SelectAllUserID false ", err.Error())
-		return &pbUser.GetAllUserIDResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
-	} else {
-		log.NewInfo(req.OperationID, "GetAllUserID rpc return ", pbUser.GetAllUserIDResp{CommonResp: &pbUser.CommonResp{}, UserIDList: uidList})
-		return &pbUser.GetAllUserIDResp{CommonResp: &pbUser.CommonResp{}, UserIDList: uidList}, nil
-	}
-}
-
-func (s *userServer) SyncJoinedGroupMemberFaceURL(userID string, faceURL string, operationID string, opUserID string) {
-	joinedGroupIDList, err := rocksCache.GetJoinedGroupIDListFromCache(userID)
-	if err != nil {
-		log.NewWarn(operationID, "GetJoinedGroupIDListByUserID failed ", userID, err.Error())
 		return
 	}
-	for _, groupID := range joinedGroupIDList {
-		groupMemberInfo := imdb.GroupMember{UserID: userID, GroupID: groupID, FaceURL: faceURL}
-		if err := imdb.UpdateGroupMemberInfo(groupMemberInfo); err != nil {
-			log.NewError(operationID, utils.GetSelfFuncName(), err.Error(), groupMemberInfo)
-			continue
-		}
-		//if err := rocksCache.DelAllGroupMembersInfoFromCache(groupID); err != nil {
-		//	log.NewError(operationID, utils.GetSelfFuncName(), err.Error(), groupID)
-		//	continue
-		//}
-		if err := rocksCache.DelGroupMemberInfoFromCache(groupID, userID); err != nil {
-			log.NewError(operationID, utils.GetSelfFuncName(), err.Error(), groupID, userID)
-			continue
-		}
-		chat.GroupMemberInfoSetNotification(operationID, opUserID, groupID, userID)
-	}
-}
-
-func (s *userServer) SyncJoinedGroupMemberNickname(userID string, newNickname, oldNickname string, operationID string, opUserID string) {
-	joinedGroupIDList, err := imdb.GetJoinedGroupIDListByUserID(userID)
+	client := pbGroup.NewGroupClient(etcdConn)
+	newReq := &pbGroup.GetJoinedGroupListReq{FromUserID: userID}
+	rpcResp, err := client.GetJoinedGroupList(ctx, newReq)
 	if err != nil {
-		log.NewWarn(operationID, "GetJoinedGroupIDListByUserID failed ", userID, err.Error())
 		return
 	}
-	for _, v := range joinedGroupIDList {
-		member, err := imdb.GetGroupMemberInfoByGroupIDAndUserID(v, userID)
+
+	for _, group := range rpcResp.Groups {
+		req := &pbGroup.SetGroupMemberInfoReq{GroupID: group.GroupID, UserID: userID, FaceURL: &wrappers.StringValue{Value: faceURL}}
+		_, err := client.SetGroupMemberInfo(ctx, req)
 		if err != nil {
-			log.NewWarn(operationID, "GetGroupMemberInfoByGroupIDAndUserID failed ", err.Error(), v, userID)
-			continue
-		}
-		if member.Nickname == oldNickname {
-			groupMemberInfo := imdb.GroupMember{UserID: userID, GroupID: v, Nickname: newNickname}
-			if err := imdb.UpdateGroupMemberInfo(groupMemberInfo); err != nil {
-				log.NewError(operationID, utils.GetSelfFuncName(), err.Error(), groupMemberInfo)
-				continue
-			}
-			//if err := rocksCache.DelAllGroupMembersInfoFromCache(v); err != nil {
-			//	log.NewError(operationID, utils.GetSelfFuncName(), err.Error(), v)
-			//	continue
-			//}
-			if err := rocksCache.DelGroupMemberInfoFromCache(v, userID); err != nil {
-				log.NewError(operationID, utils.GetSelfFuncName(), err.Error(), v)
-			}
-			chat.GroupMemberInfoSetNotification(operationID, opUserID, v, userID)
+			return
 		}
+		chat.GroupMemberInfoSetNotification(operationID, opUserID, group.GroupID, userID)
 	}
 }

-func (s *userServer) AddUser(ctx context.Context, req *pbUser.AddUserReq) (*pbUser.AddUserResp, error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
-	resp := &pbUser.AddUserResp{CommonResp: &pbUser.CommonResp{}}
-	err := imdb.AddUser(req.UserInfo.UserID, req.UserInfo.PhoneNumber, req.UserInfo.Nickname, req.UserInfo.Email, req.UserInfo.Gender, req.UserInfo.FaceURL, req.UserInfo.BirthStr)
+func (s *userServer) SyncJoinedGroupMemberNickname(ctx context.Context, userID string, newNickname, oldNickname string, operationID string, opUserID string) {
+	etcdConn, err := getcdv3.GetConn(ctx, config.Config.RpcRegisterName.OpenImFriendName)
 	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "AddUser", err.Error(), req.String())
-		resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
-		resp.CommonResp.ErrMsg = err.Error()
-		return resp, nil
+		return
+	}
+	client := pbGroup.NewGroupClient(etcdConn)
+	newReq := &pbGroup.GetJoinedGroupListReq{FromUserID: userID}
+	rpcResp, err := client.GetJoinedGroupList(ctx, newReq)
+	if err != nil {
+		return
+	}
+	req := pbGroup.GetUserInGroupMembersReq{UserID: userID}
+	for _, group := range rpcResp.Groups {
+		req.GroupIDs = append(req.GroupIDs, group.GroupID)
+	}
+	resp, err := client.GetUserInGroupMembers(ctx, &req)
+	if err != nil {
+		return
+	}
+	for _, v := range resp.Members {
+		if v.Nickname == oldNickname {
+			req := pbGroup.SetGroupMemberNicknameReq{Nickname: newNickname, GroupID: v.GroupID, UserID: v.UserID}
+			_, err := client.SetGroupMemberNickname(ctx, &req)
+			if err != nil {
+				return
+			}
+			chat.GroupMemberInfoSetNotification(operationID, opUserID, v.GroupID, userID)
+		}
 	}
-	return resp, nil
 }

 func (s *userServer) GetUsersInfo(ctx context.Context, req *pbUser.GetUsersInfoReq) (*pbUser.GetUsersInfoResp, error) {
@@ -447,7 +188,6 @@ func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbUser.UpdateUserI
 	if err != nil {
 		return nil, err
 	}
-
 	oldNickname := ""
 	if req.UserInfo.Nickname != "" {
 		u, err := s.Take(ctx, req.UserInfo.UserID)
@@ -456,7 +196,6 @@ func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbUser.UpdateUserI
 		}
 		oldNickname = u.Nickname
 	}
-
 	user, err := utils2.NewPBUser(req.UserInfo).Convert()
 	if err != nil {
 		return nil, err
@@ -469,36 +208,26 @@ func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbUser.UpdateUserI
 	if err != nil {
 		return nil, err
 	}
-
 	client := pbFriend.NewFriendClient(etcdConn)
-	newReq := &pbFriend.GetFriendListReq{
-		CommID: &pbFriend.CommID{OperationID: req.OperationID, FromUserID: req.UserInfo.UserID, OpUserID: req.OpUserID},
-	}
-
+	newReq := &pbFriend.GetFriendListReq{UserID: req.UserInfo.UserID}
 	rpcResp, err := client.GetFriendList(context.Background(), newReq)
 	if err != nil {
-		log.NewError(req.OperationID, "GetFriendList failed ", err.Error(), newReq)
-		return &pbUser.UpdateUserInfoResp{CommonResp: &pbUser.CommonResp{ErrCode: 500, ErrMsg: err.Error()}}, nil
+		return nil, err
 	}
-	for _, v := range rpcResp.FriendInfoList {
-		log.Info(req.OperationID, "UserInfoUpdatedNotification ", req.UserInfo.UserID, v.FriendUser.UserID)
-		//	chat.UserInfoUpdatedNotification(req.OperationID, req.UserInfo.UserID, v.FriendUser.UserID)
-		chat.FriendInfoUpdatedNotification(req.OperationID, req.UserInfo.UserID, v.FriendUser.UserID, req.OpUserID)
-	}
-	if err := rocksCache.DelUserInfoFromCache(user.UserID); err != nil {
-		log.NewError(req.OperationID, "GetFriendList failed ", err.Error(), newReq)
-		return &pbUser.UpdateUserInfoResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: err.Error()}}, nil
-	}
-	//chat.UserInfoUpdatedNotification(req.OperationID, req.OpUserID, req.UserInfo.UserID)
-	chat.UserInfoUpdatedNotification(req.OperationID, req.OpUserID, req.UserInfo.UserID)
-	log.Info(req.OperationID, "UserInfoUpdatedNotification ", req.UserInfo.UserID, req.OpUserID)
+	go func() {
+		for _, v := range rpcResp.FriendInfoList {
+			chat.FriendInfoUpdatedNotification(tools.OperationID(ctx), req.UserInfo.UserID, v.FriendUser.UserID, tools.OpUserID(ctx))
+		}
+	}()
+
+	chat.UserInfoUpdatedNotification(tools.OperationID(ctx), tools.OpUserID(ctx), req.UserInfo.UserID)
 	if req.UserInfo.FaceURL != "" {
-		s.SyncJoinedGroupMemberFaceURL(req.UserInfo.UserID, req.UserInfo.FaceURL, req.OperationID, req.OpUserID)
+		s.SyncJoinedGroupMemberFaceURL(ctx, req.UserInfo.UserID, req.UserInfo.FaceURL, tools.OperationID(ctx), tools.OpUserID(ctx))
 	}
 	if req.UserInfo.Nickname != "" {
-		s.SyncJoinedGroupMemberNickname(req.UserInfo.UserID, req.UserInfo.Nickname, oldNickname, req.OperationID, req.OpUserID)
+		s.SyncJoinedGroupMemberNickname(ctx, req.UserInfo.UserID, req.UserInfo.Nickname, oldNickname, tools.OperationID(ctx), tools.OpUserID(ctx))
 	}
-	return &pbUser.UpdateUserInfoResp{CommonResp: &pbUser.CommonResp{}}, nil
+	return &resp, nil
 }

 func (s *userServer) SetGlobalRecvMessageOpt(ctx context.Context, req *pbUser.SetGlobalRecvMessageOptReq) (*pbUser.SetGlobalRecvMessageOptResp, error) {
@@ -559,74 +288,48 @@ func (s *userServer) GetUsers(ctx context.Context, req *pbUser.GetUsersReq) (*pb
 	}

 	if req.UserName != "" {
-		usersDB, err = imdb.GetUserByName(req.UserName, req.Pagination.ShowNumber, req.Pagination.PageNumber)
+		usersDB, total, err := s.GetByName(ctx, req.UserName, req.Pagination.ShowNumber, req.Pagination.PageNumber)
 		if err != nil {
-			log.NewError(req.OperationID, utils.GetSelfFuncName(), req.UserName, req.Pagination.ShowNumber, req.Pagination.PageNumber, err.Error())
-			resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
-			resp.CommonResp.ErrMsg = constant.ErrDB.ErrMsg
-			return resp, nil
+			return nil, err
 		}
-		resp.TotalNums, err = imdb.GetUsersCount(req.UserName)
-		if err != nil {
-			log.NewError(req.OperationID, utils.GetSelfFuncName(), req.UserName, err.Error())
-			resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
-			resp.CommonResp.ErrMsg = err.Error()
-			return resp, nil
+		resp.Total = int32(total)
+		for _, v := range usersDB {
+			u1, err := utils2.NewDBUser(v).Convert()
+			if err != nil {
+				return nil, err
+			}
+			resp.Users = append(resp.Users, u1)
 		}
-
+		return &resp, nil
 	} else if req.Content != "" {
-		var count int64
-		usersDB, count, err = imdb.GetUsersByNameAndID(req.Content, req.Pagination.ShowNumber, req.Pagination.PageNumber)
+		usersDB, total, err := s.GetByNameAndID(ctx, req.UserName, req.Pagination.ShowNumber, req.Pagination.PageNumber)
 		if err != nil {
-			log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUsers failed", req.Pagination.ShowNumber, req.Pagination.PageNumber, err.Error())
-			resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
-			resp.CommonResp.ErrMsg = err.Error()
-			return resp, nil
+			return nil, err
 		}
-		resp.TotalNums = int32(count)
+		resp.Total = int32(total)
+		for _, v := range usersDB {
+			u1, err := utils2.NewDBUser(v).Convert()
+			if err != nil {
+				return nil, err
+			}
+			resp.Users = append(resp.Users, u1)
+		}
+		return &resp, nil
 	}

-	else {
-		usersDB, err = imdb.GetUsers(req.Pagination.ShowNumber, req.Pagination.PageNumber)
-		if err != nil {
-			log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUsers failed", req.Pagination.ShowNumber, req.Pagination.PageNumber, err.Error())
-			resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
-			resp.CommonResp.ErrMsg = err.Error()
-			return resp, nil
-		}
-		resp.TotalNums, err = imdb.GetTotalUserNum()
-		if err != nil {
-			log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
-			resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
-			resp.CommonResp.ErrMsg = err.Error()
-			return resp, nil
-		}
-	}
-	for _, userDB := range usersDB {
-		var user sdkws.UserInfo
-		utils.CopyStructFields(&user, userDB)
-		user.CreateTime = uint32(userDB.CreateTime.Unix())
-		user.BirthStr = utils.TimeToString(userDB.Birth)
-		resp.UserList = append(resp.UserList, &pbUser.CmsUser{User: &user})
-	}
-
-	var userIDList []string
-	for _, v := range resp.UserList {
-		userIDList = append(userIDList, v.User.UserID)
-	}
-	isBlockUser, err := imdb.UsersIsBlock(userIDList)
+	usersDB, total, err := s.Get(ctx, req.Pagination.ShowNumber, req.Pagination.PageNumber)
 	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), userIDList)
-		resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
-		resp.CommonResp.ErrMsg = err.Error()
-		return resp, nil
+		return nil, err
 	}

-	for _, v := range resp.UserList {
-		if utils.IsContain(v.User.UserID, isBlockUser) {
-			v.IsBlock = true
+	resp.Total = int32(total)
+
+	for _, userDB := range usersDB {
+		u, err := utils2.NewDBUser(userDB).Convert()
+		if err != nil {
+			return nil, err
 		}
+		resp.Users = append(resp.Users, u)
 	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
-	return resp, nil
+	return &resp, nil
 }