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

internal/common/convert/convert.go

@@ -0,0 +1,292 @@
+package convert
+
+import (
+	"Open_IM/pkg/common/db/relation"
+	sdk "Open_IM/pkg/proto/sdk_ws"
+	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 {
+	*relation.Friend
+}
+
+func NewDBFriend(friend *relation.Friend) *DBFriend {
+	return &DBFriend{Friend: friend}
+}
+
+type PBFriend struct {
+	*sdk.FriendInfo
+}
+
+func NewPBFriend(friendInfo *sdk.FriendInfo) *PBFriend {
+	return &PBFriend{FriendInfo: 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
+	}
+	utils.CopyStructFields(pbFriend.FriendUser, user[0])
+	pbFriend.CreateTime = db.CreateTime.Unix()
+
+	pbFriend.FriendUser.CreateTime = db.CreateTime.Unix()
+	return pbFriend, nil
+}
+
+func (pb *PBFriend) Convert() (*relation.Friend, error) {
+	dbFriend := &relation.Friend{}
+	utils.CopyStructFields(dbFriend, pb)
+	dbFriend.FriendUserID = pb.FriendUser.UserID
+	dbFriend.CreateTime = utils.UnixSecondToTime(pb.CreateTime)
+	return dbFriend, nil
+}
+
+type DBFriendRequest struct {
+	*relation.FriendRequest
+}
+
+func NewDBFriendRequest(friendRequest *relation.FriendRequest) *DBFriendRequest {
+	return &DBFriendRequest{FriendRequest: friendRequest}
+}
+
+type PBFriendRequest struct {
+	*sdk.FriendRequest
+}
+
+func NewPBFriendRequest(friendRequest *sdk.FriendRequest) *PBFriendRequest {
+	return &PBFriendRequest{FriendRequest: friendRequest}
+}
+
+func (pb *PBFriendRequest) Convert() (*relation.FriendRequest, error) {
+	dbFriendRequest := &relation.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 = db.CreateTime.Unix()
+	pbFriendRequest.HandleTime = db.HandleTime.Unix()
+	return pbFriendRequest, nil
+}
+
+type DBBlack struct {
+	*relation.Black
+}
+
+func NewDBBlack(black *relation.Black) *DBBlack {
+	return &DBBlack{Black: black}
+}
+
+type PBBlack struct {
+	*sdk.BlackInfo
+}
+
+func NewPBBlack(blackInfo *sdk.BlackInfo) *PBBlack {
+	return &PBBlack{BlackInfo: blackInfo}
+}
+
+func (pb *PBBlack) Convert() (*relation.Black, error) {
+	dbBlack := &relation.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 = 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 {
+	*relation.Group
+}
+
+func NewDBGroup(group *relation.Group) *DBGroup {
+	return &DBGroup{Group: group}
+}
+
+type PBGroup struct {
+	*sdk.GroupInfo
+}
+
+func NewPBGroup(groupInfo *sdk.GroupInfo) *PBGroup {
+	return &PBGroup{GroupInfo: groupInfo}
+}
+
+func (pb *PBGroup) Convert() *relation.Group {
+	dst := &relation.Group{}
+	_ = utils.CopyStructFields(dst, pb)
+	return dst
+}
+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 = db.CreateTime.Unix()
+	dst.NotificationUpdateTime = db.NotificationUpdateTime.Unix()
+	if db.NotificationUpdateTime.Unix() < 0 {
+		dst.NotificationUpdateTime = 0
+	}
+	return dst, nil
+}
+
+type DBGroupMember struct {
+	*relation.GroupMember
+}
+
+func NewDBGroupMember(groupMember *relation.GroupMember) *DBGroupMember {
+	return &DBGroupMember{GroupMember: groupMember}
+}
+
+type PBGroupMember struct {
+	*sdk.GroupMemberFullInfo
+}
+
+func NewPBGroupMember(groupMemberFullInfo *sdk.GroupMemberFullInfo) *PBGroupMember {
+	return &PBGroupMember{GroupMemberFullInfo: groupMemberFullInfo}
+}
+
+func (pb *PBGroupMember) Convert() (*relation.GroupMember, error) {
+	dst := &relation.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 = db.JoinTime.Unix()
+	if db.JoinTime.Unix() < 0 {
+		dst.JoinTime = 0
+	}
+	dst.MuteEndTime = db.MuteEndTime.Unix()
+	if dst.MuteEndTime < time.Now().Unix() {
+		dst.MuteEndTime = 0
+	}
+	return dst, nil
+}
+
+type DBGroupRequest struct {
+	*relation.GroupRequest
+}
+
+func NewDBGroupRequest(groupRequest *relation.GroupRequest) *DBGroupRequest {
+	return &DBGroupRequest{GroupRequest: groupRequest}
+}
+
+type PBGroupRequest struct {
+	*sdk.GroupRequest
+}
+
+func NewPBGroupRequest(groupRequest *sdk.GroupRequest) *PBGroupRequest {
+	return &PBGroupRequest{GroupRequest: groupRequest}
+}
+
+func (pb *PBGroupRequest) Convert() (*relation.GroupRequest, error) {
+	dst := &relation.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 = db.ReqTime.Unix()
+	dst.HandleTime = db.HandledTime.Unix()
+	return dst, nil
+}
+
+type DBUser struct {
+	*relation.User
+}
+
+func NewDBUser(user *relation.User) *DBUser {
+	return &DBUser{User: user}
+}
+
+type PBUser struct {
+	*sdk.UserInfo
+}
+
+func NewPBUser(userInfo *sdk.UserInfo) *PBUser {
+	return &PBUser{UserInfo: userInfo}
+}
+
+func (pb *PBUser) Convert() (*relation.User, error) {
+	dst := &relation.User{}
+	utils.CopyStructFields(dst, pb)
+	dst.Birth = utils.UnixSecondToTime(pb.Birthday)
+	dst.CreateTime = utils.UnixSecondToTime(int64(pb.CreateTime))
+	return dst, nil
+}
+
+func (db *DBUser) Convert() (*sdk.UserInfo, error) {
+	dst := &sdk.UserInfo{}
+	utils.CopyStructFields(dst, db)
+	dst.CreateTime = db.CreateTime.Unix()
+	dst.Birthday = db.Birth.Unix()
+	return dst, nil
+}
+
+func (db *DBUser) ConvertPublic() (*sdk.PublicUserInfo, error) {
+	dst := &sdk.PublicUserInfo{}
+	utils.CopyStructFields(dst, db)
+	return dst, nil
+}

internal/rpc/friend/black.go

@@ -0,0 +1,70 @@
+package friend
+
+import (
+	"Open_IM/internal/common/check"
+	"Open_IM/internal/common/convert"
+	chat "Open_IM/internal/rpc/msg"
+	"Open_IM/pkg/common/db/relation"
+	"Open_IM/pkg/common/token_verify"
+	"Open_IM/pkg/common/tracelog"
+	pbFriend "Open_IM/pkg/proto/friend"
+	"context"
+)
+
+func (s *friendServer) GetBlacks(ctx context.Context, req *pbFriend.GetBlacksReq) (*pbFriend.GetBlacksResp, error) {
+	resp := &pbFriend.GetBlacksResp{}
+	if err := check.Access(ctx, req.UserID); err != nil {
+		return nil, err
+	}
+	blacks, total, err := s.BlackInterface.FindOwnerBlacks(ctx, req.UserID, req.Pagination.PageNumber, req.Pagination.ShowNumber)
+	if err != nil {
+		return nil, err
+	}
+	blackIDList := make([]string, 0, len(blacks))
+	for _, black := range blacks {
+		b, err := convert.NewDBBlack(black).Convert()
+		if err != nil {
+			return nil, err
+		}
+		resp.Blacks = append(resp.Blacks, b)
+		blackIDList = append(blackIDList, black.BlockUserID)
+	}
+	resp.Total = int32(total)
+	return resp, nil
+}
+
+func (s *friendServer) IsBlack(ctx context.Context, req *pbFriend.IsBlackReq) (*pbFriend.IsBlackResp, error) {
+	resp := &pbFriend.IsBlackResp{}
+	in1, in2, err := s.BlackInterface.CheckIn(ctx, req.UserID1, req.UserID2)
+	if err != nil {
+		return nil, err
+	}
+	resp.InUser1Blacks = in1
+	resp.InUser2Blacks = in2
+	return resp, nil
+}
+
+func (s *friendServer) RemoveBlack(ctx context.Context, req *pbFriend.RemoveBlackReq) (*pbFriend.RemoveBlackResp, error) {
+	resp := &pbFriend.RemoveBlackResp{}
+	if err := check.Access(ctx, req.OwnerUserID); err != nil {
+		return nil, err
+	}
+	if err := s.BlackInterface.Delete(ctx, []*relation.Black{{OwnerUserID: req.OwnerUserID, BlockUserID: req.BlackUserID}}); err != nil {
+		return nil, err
+	}
+	chat.BlackDeletedNotification(req)
+	return resp, nil
+}
+
+func (s *friendServer) AddBlack(ctx context.Context, req *pbFriend.AddBlackReq) (*pbFriend.AddBlackResp, error) {
+	resp := &pbFriend.AddBlackResp{}
+	if err := token_verify.CheckAccessV3(ctx, req.OwnerUserID); err != nil {
+		return nil, err
+	}
+	black := relation.Black{OwnerUserID: req.OwnerUserID, BlockUserID: req.BlackUserID, OperatorUserID: tracelog.GetOpUserID(ctx)}
+	if err := s.BlackInterface.Create(ctx, []*relation.Black{&black}); err != nil {
+		return nil, err
+	}
+	chat.BlackAddedNotification(req)
+	return resp, nil
+}

internal/rpc/friend/friend.go

@@ -1,17 +1,17 @@
 package friend
 
 import (
+	"Open_IM/internal/common/convert"
 	chat "Open_IM/internal/rpc/msg"
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/db/controller"
-	"Open_IM/pkg/common/tracelog"
-
 	"Open_IM/pkg/common/db/relation"
 	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/common/middleware"
 	promePkg "Open_IM/pkg/common/prometheus"
 	"Open_IM/pkg/common/token_verify"
+	"Open_IM/pkg/common/tracelog"
 	"Open_IM/pkg/getcdv3"
 	pbFriend "Open_IM/pkg/proto/friend"
 	sdkws "Open_IM/pkg/proto/sdk_ws"
@@ -115,19 +115,6 @@ func (s *friendServer) Run() {
 	}
 }
 
-func (s *friendServer) AddBlack(ctx context.Context, req *pbFriend.AddBlackReq) (*pbFriend.AddBlackResp, error) {
-	resp := &pbFriend.AddBlackResp{}
-	if err := token_verify.CheckAccessV3(ctx, req.OwnerUserID); err != nil {
-		return nil, err
-	}
-	black := relation.Black{OwnerUserID: req.OwnerUserID, BlockUserID: req.BlackUserID, OperatorUserID: tracelog.OpUserID(ctx)}
-	if err := s.BlackInterface.Create(ctx, []*relation.Black{&black}); err != nil {
-		return nil, err
-	}
-	chat.BlackAddedNotification(req)
-	return resp, nil
-}
-
 func (s *friendServer) AddFriend(ctx context.Context, req *pbFriend.AddFriendReq) (*pbFriend.AddFriendResp, error) {
 	resp := &pbFriend.AddFriendResp{}
 	if err := token_verify.CheckAccessV3(ctx, req.FromUserID); err != nil {
@@ -157,7 +144,7 @@ func (s *friendServer) AddFriend(ctx context.Context, req *pbFriend.AddFriendReq
 	return resp, nil
 }
 
-func (s *friendServer) ImportFriend(ctx context.Context, req *pbFriend.ImportFriendReq) (*pbFriend.ImportFriendResp, error) {
+func (s *friendServer) ImportFriends(ctx context.Context, req *pbFriend.ImportFriendReq) (*pbFriend.ImportFriendResp, error) {
 	resp := &pbFriend.ImportFriendResp{}
 	if err := token_verify.CheckAdmin(ctx); err != nil {
 		return nil, err
@@ -168,7 +155,7 @@ func (s *friendServer) ImportFriend(ctx context.Context, req *pbFriend.ImportFri
 
 	var friends []*relation.Friend
 	for _, userID := range utils.RemoveDuplicateElement(req.FriendUserIDs) {
-		friends = append(friends, &relation.Friend{OwnerUserID: userID, FriendUserID: req.OwnerUserID, AddSource: constant.BecomeFriendByImport, OperatorUserID: tools.OpUserID(ctx)})
+		friends = append(friends, &relation.Friend{OwnerUserID: userID, FriendUserID: req.OwnerUserID, AddSource: constant.BecomeFriendByImport, OperatorUserID: tracelog.GetOpUserID(ctx)})
 	}
 	if len(friends) > 0 {
 		if err := s.FriendInterface.BecomeFriend(ctx, friends); err != nil {
@@ -181,7 +168,7 @@ func (s *friendServer) ImportFriend(ctx context.Context, req *pbFriend.ImportFri
 // process Friend application
 func (s *friendServer) RespondFriendApply(ctx context.Context, req *pbFriend.RespondFriendApplyReq) (*pbFriend.RespondFriendApplyResp, error) {
 	resp := &pbFriend.RespondFriendApplyResp{}
-	if err := token_verify.CheckAccessV3(ctx, req.ToUserID); err != nil {
+	if err := check.Access(ctx, req.ToUserID); err != nil {
 		return nil, err
 	}
 	friendRequest := relation.FriendRequest{FromUserID: req.FromUserID, ToUserID: req.ToUserID, HandleMsg: req.HandleMsg, HandleResult: req.HandleResult}
@@ -206,7 +193,7 @@ func (s *friendServer) RespondFriendApply(ctx context.Context, req *pbFriend.Res
 
 func (s *friendServer) DeleteFriend(ctx context.Context, req *pbFriend.DeleteFriendReq) (*pbFriend.DeleteFriendResp, error) {
 	resp := &pbFriend.DeleteFriendResp{}
-	if err := token_verify.CheckAccessV3(ctx, req.OwnerUserID); err != nil {
+	if err := check.Access(ctx, req.OwnerUserID); err != nil {
 		return nil, err
 	}
 	if err := s.FriendInterface.Delete(ctx, req.OwnerUserID, req.FriendUserID); err != nil {
@@ -218,35 +205,22 @@ func (s *friendServer) DeleteFriend(ctx context.Context, req *pbFriend.DeleteFri
 
 func (s *friendServer) SetFriendRemark(ctx context.Context, req *pbFriend.SetFriendRemarkReq) (*pbFriend.SetFriendRemarkResp, error) {
 	resp := &pbFriend.SetFriendRemarkResp{}
-	if err := token_verify.CheckAccessV3(ctx, req.OwnerUserID); err != nil {
+	if err := check.Access(ctx, req.OwnerUserID); err != nil {
 		return nil, err
 	}
 	if err := s.FriendInterface.UpdateRemark(ctx, req.OwnerUserID, req.FriendUserID, req.Remark); err != nil {
 		return nil, err
 	}
-	chat.FriendRemarkSetNotification(tools.OperationID(ctx), tools.OpUserID(ctx), req.OwnerUserID, req.FriendUserID)
+	chat.FriendRemarkSetNotification(tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx), req.OwnerUserID, req.FriendUserID)
 	return resp, nil
 }
 
-func (s *friendServer) RemoveBlacklist(ctx context.Context, req *pbFriend.RemoveBlackReq) (*pbFriend.RemoveBlackResp, error) {
-	resp := &pbFriend.RemoveBlacklistResp{}
-	//Parse token, to find current user information
-	if err := token_verify.CheckAccessV3(ctx, req.FromUserID); err != nil {
+func (s *friendServer) GetFriends(ctx context.Context, req *pbFriend.GetFriendsReq) (*pbFriend.GetFriendsResp, error) {
+	resp := &pbFriend.GetFriendsResp{}
+	if err := check.Access(ctx, req.UserID); err != nil {
 		return nil, err
 	}
-	if err := s.BlackInterface.Delete(ctx, []*relation.Black{{OwnerUserID: req.FromUserID, BlockUserID: req.ToUserID}}); err != nil {
-		return nil, err
-	}
-	chat.BlackDeletedNotification(req)
-	return resp, nil
-}
-
-func (s *friendServer) GetFriendList(ctx context.Context, req *pbFriend.GetFriendListReq) (*pbFriend.GetFriendListResp, error) {
-	resp := &pbFriend.GetFriendListResp{}
-	if err := token_verify.CheckAccessV3(ctx, req.FromUserID); err != nil {
-		return nil, err
-	}
-	friends, err := s.FriendInterface.FindOwnerUserID(ctx, req.FromUserID)
+	friends, err := s.FriendInterface.FindOwnerFriends(ctx, req.UserID, req.Pagination.PageNumber, req.Pagination.ShowNumber)
 	if err != nil {
 		return nil, err
 	}
@@ -254,7 +228,7 @@ func (s *friendServer) GetFriendList(ctx context.Context, req *pbFriend.GetFrien
 	for _, f := range friends {
 		userIDList = append(userIDList, f.FriendUserID)
 	}
-	users, err := GetUsersInfo(ctx, userIDList)
+	users, err := check.GetUsersInfo(ctx, userIDList)
 	if err != nil {
 		return nil, err
 	}
@@ -263,124 +237,79 @@ func (s *friendServer) GetFriendList(ctx context.Context, req *pbFriend.GetFrien
 		userMap[user.UserID] = users[i]
 	}
 	for _, friendUser := range friends {
-		friendUserInfo := sdkws.FriendInfo{FriendUser: userMap[friendUser.FriendUserID]}
-		utils.CopyStructFields(&friendUserInfo, friendUser)
-		resp.FriendInfoList = append(resp.FriendInfoList, &friendUserInfo)
-	}
-	return resp, nil
-}
 
-// received
-func (s *friendServer) GetFriendApplyList(ctx context.Context, req *pbFriend.GetFriendApplyListReq) (*pbFriend.GetFriendApplyListResp, error) {
-	resp := &pbFriend.GetFriendApplyListResp{}
-	//Parse token, to find current user information
-	if err := token_verify.CheckAccessV3(ctx, req.FromUserID); err != nil {
-		return nil, err
-	}
-	//	Find the  current user friend applications received
-	friendRequests, err := s.friendRequestModel.FindToUserID(ctx, req.FromUserID)
-	if err != nil {
-		return nil, err
-	}
-	userIDList := make([]string, 0, len(friendRequests))
-	for _, f := range friendRequests {
-		userIDList = append(userIDList, f.FromUserID)
-	}
-	users, err := GetPublicUserInfoBatch(ctx, userIDList)
-	if err != nil {
-		return nil, err
-	}
-	userMap := make(map[string]*sdkws.PublicUserInfo)
-	for i, user := range users {
-		userMap[user.UserID] = users[i]
-	}
-	for _, friendRequest := range friendRequests {
-		var userInfo sdkws.FriendRequest
-		if u, ok := userMap[friendRequest.FromUserID]; ok {
-			utils.CopyStructFields(&userInfo, u)
+		friendUserInfo, err := (convert.NewDBFriend(friendUser)).Convert()
+		if err != nil {
+			return nil, err
 		}
-		utils.CopyStructFields(&userInfo, friendRequest)
-		resp.FriendRequestList = append(resp.FriendRequestList, &userInfo)
+		resp.FriendsInfo = append(resp.FriendsInfo, friendUserInfo)
 	}
 	return resp, nil
 }
 
-func (s *friendServer) GetSelfApplyList(ctx context.Context, req *pbFriend.GetSelfApplyListReq) (*pbFriend.GetSelfApplyListResp, error) {
-	resp := &pbFriend.GetSelfApplyListResp{}
-	//Parse token, to find current user information
-	if err := token_verify.CheckAccessV3(ctx, req.FromUserID); err != nil {
+// 获取接收到的好友申请（即别人主动申请的）
+func (s *friendServer) GetToFriendsApply(ctx context.Context, req *pbFriend.GetToFriendsApplyReq) (*pbFriend.GetToFriendsApplyResp, error) {
+	resp := &pbFriend.GetToFriendsApplyResp{}
+	if err := check.Access(ctx, req.UserID); err != nil {
 		return nil, err
 	}
-	//	Find the self add other userinfo
-	friendRequests, err := s.FriendRequestInterface.FindFromUserID(ctx, req.FromUserID)
+	friendRequests, err := s.FriendInterface.FindFriendRequestToMe(ctx, req.UserID, req.Pagination.PageNumber, req.Pagination.ShowNumber)
 	if err != nil {
 		return nil, err
 	}
-	userIDList := make([]string, 0, len(friendRequests))
-	for _, f := range friendRequests {
-		userIDList = append(userIDList, f.ToUserID)
-	}
-	users, err := GetPublicUserInfoBatch(ctx, userIDList)
-	if err != nil {
-		return nil, err
-	}
-	userMap := make(map[string]*sdkws.PublicUserInfo)
-	for i, user := range users {
-		userMap[user.UserID] = users[i]
-	}
-	for _, friendRequest := range friendRequests {
-		var userInfo sdkws.FriendRequest
-		if u, ok := userMap[friendRequest.ToUserID]; ok {
-			utils.CopyStructFields(&userInfo, u)
+	for _, v := range friendRequests {
+		fUser, err := convert.NewDBFriendRequest(v).Convert()
+		if err != nil {
+			return nil, err
 		}
-		utils.CopyStructFields(&userInfo, friendRequest)
-		resp.FriendRequestList = append(resp.FriendRequestList, &userInfo)
+		resp.FriendRequests = append(resp.FriendRequests, fUser)
 	}
 	return resp, nil
 }
 
-func (s *friendServer) GetBlacklist(ctx context.Context, req *pbFriend.GetBlacklistReq) (*pbFriend.GetBlacklistResp, error) {
-	resp := &pbFriend.GetBlacklistResp{}
-	if err := token_verify.CheckAccessV3(ctx, req.FromUserID); err != nil {
+// 获取主动发出去的好友申请列表
+func (s *friendServer) GetFromFriendsApply(ctx context.Context, req *pbFriend.GetFromFriendsApplyReq) (*pbFriend.GetFromFriendsApplyResp, error) {
+	resp := &pbFriend.GetFromFriendsApplyResp{}
+	if err := check.Access(ctx, req.UserID); err != nil {
 		return nil, err
 	}
-	blacks, err := s.BlackInterface.FindByOwnerUserID(ctx, req.FromUserID)
+	friendRequests, err := s.FriendInterface.FindFriendRequestFromMe(ctx, req.UserID, req.Pagination.PageNumber, req.Pagination.ShowNumber)
 	if err != nil {
 		return nil, err
 	}
-	blackIDList := make([]string, 0, len(blacks))
-	for _, black := range blacks {
-		blackIDList = append(blackIDList, black.BlockUserID)
+	for _, v := range friendRequests {
+		fUser, err := convert.NewDBFriendRequest(v).Convert()
+		if err != nil {
+			return nil, err
+		}
+		resp.FriendRequests = append(resp.FriendRequests, fUser)
 	}
-	resp.BlackUserInfoList, err = GetPublicUserInfoBatch(ctx, blackIDList)
-	if err != nil {
-		return nil, err
-	}
-	return resp, nil
-}
-
-func (s *friendServer) IsInBlackList(ctx context.Context, req *pbFriend.IsInBlackListReq) (*pbFriend.IsInBlackListResp, error) {
-	resp := &pbFriend.IsInBlackListResp{}
-	if err := token_verify.CheckAccessV3(ctx, req.FromUserID); err != nil {
-		return nil, err
-	}
-	exist, err := s.BlackInterface.IsExist(ctx, req.FromUserID, req.ToUserID)
-	if err != nil {
-		return nil, err
-	}
-	resp.Response = exist
 	return resp, nil
 }
 
 func (s *friendServer) IsFriend(ctx context.Context, req *pbFriend.IsFriendReq) (*pbFriend.IsFriendResp, error) {
 	resp := &pbFriend.IsFriendResp{}
-	if err := token_verify.CheckAccessV3(ctx, req.FromUserID); err != nil {
-		return nil, err
-	}
-	exist, err := s.FriendInterface.IsExist(ctx, req.FromUserID, req.ToUserID)
+	err, in1, in2 := s.FriendInterface.CheckIn(ctx, req.UserID1, req.UserID2)
 	if err != nil {
 		return nil, err
 	}
-	resp.Response = exist
+	resp.InUser1Friends = in1
+	resp.InUser2Friends = in2
 	return resp, nil
 }
+
+func (s *friendServer) GetFriendsInfo(ctx context.Context, req *pbFriend.GetFriendsInfoReq) (*pbFriend.GetFriendsInfoResp, error) {
+	resp := pbFriend.GetFriendsInfoResp{}
+	friends, err := s.FriendInterface.FindFriends(ctx, req.OwnerUserID, req.FriendUserIDs)
+	if err != nil {
+		return nil, err
+	}
+	for _, v := range friends {
+		fUser, err := convert.NewDBFriend(v).Convert()
+		if err != nil {
+			return nil, err
+		}
+		resp.FriendsInfo = append(resp.FriendsInfo, fUser)
+	}
+	return &resp, nil
+}

internal/rpc/user/user.go

@@ -1,6 +1,7 @@
 package user
 
 import (
+	"Open_IM/internal/common/convert"
 	chat "Open_IM/internal/rpc/msg"
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
@@ -9,6 +10,7 @@ import (
 	"Open_IM/pkg/common/log"
 	promePkg "Open_IM/pkg/common/prometheus"
 	"Open_IM/pkg/common/token_verify"
+	"Open_IM/pkg/common/tracelog"
 	"Open_IM/pkg/getcdv3"
 	pbFriend "Open_IM/pkg/proto/friend"
 	pbGroup "Open_IM/pkg/proto/group"
@@ -171,7 +173,7 @@ func (s *userServer) GetUsersInfo(ctx context.Context, req *pbUser.GetUsersInfoR
 		return nil, err
 	}
 	for _, v := range users {
-		n, err := utils.NewDBUser(v).Convert()
+		n, err := convert.NewDBUser(v).Convert()
 		if err != nil {
 			return nil, err
 		}
@@ -188,13 +190,13 @@ func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbUser.UpdateUserI
 	}
 	oldNickname := ""
 	if req.UserInfo.Nickname != "" {
-		u, err := s.Take(ctx, req.UserInfo.UserID)
+		u, err := s.Find(ctx, []string{req.UserInfo.UserID})
 		if err != nil {
 			return nil, err
 		}
-		oldNickname = u.Nickname
+		oldNickname = u[0].Nickname
 	}
-	user, err := utils.NewPBUser(req.UserInfo).Convert()
+	user, err := convert.NewPBUser(req.UserInfo).Convert()
 	if err != nil {
 		return nil, err
 	}
@@ -207,23 +209,23 @@ func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbUser.UpdateUserI
 		return nil, err
 	}
 	client := pbFriend.NewFriendClient(etcdConn)
-	newReq := &pbFriend.GetFriendListReq{UserID: req.UserInfo.UserID}
-	rpcResp, err := client.GetFriendList(context.Background(), newReq)
+	newReq := &pbFriend.GetFriendsReq{UserID: req.UserInfo.UserID}
+	rpcResp, err := client.GetFriends(context.Background(), newReq)
 	if err != nil {
 		return nil, err
 	}
 	go func() {
-		for _, v := range rpcResp.FriendInfoList {
-			chat.FriendInfoUpdatedNotification(utils.OperationID(ctx), req.UserInfo.UserID, v.FriendUser.UserID, utils.OpUserID(ctx))
+		for _, v := range rpcResp.FriendsInfo {
+			chat.FriendInfoUpdatedNotification(tracelog.GetOperationID(ctx), req.UserInfo.UserID, v.FriendUser.UserID, tracelog.GetOpUserID(ctx))
 		}
 	}()
 
-	chat.UserInfoUpdatedNotification(utils.OperationID(ctx), utils.OpUserID(ctx), req.UserInfo.UserID)
+	chat.UserInfoUpdatedNotification(tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx), req.UserInfo.UserID)
 	if req.UserInfo.FaceURL != "" {
-		s.SyncJoinedGroupMemberFaceURL(ctx, req.UserInfo.UserID, req.UserInfo.FaceURL, utils.OperationID(ctx), utils.OpUserID(ctx))
+		s.SyncJoinedGroupMemberFaceURL(ctx, req.UserInfo.UserID, req.UserInfo.FaceURL, tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx))
 	}
 	if req.UserInfo.Nickname != "" {
-		s.SyncJoinedGroupMemberNickname(ctx, req.UserInfo.UserID, req.UserInfo.Nickname, oldNickname, utils.OperationID(ctx), utils.OpUserID(ctx))
+		s.SyncJoinedGroupMemberNickname(ctx, req.UserInfo.UserID, req.UserInfo.Nickname, oldNickname, tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx))
 	}
 	return &resp, nil
 }
@@ -236,13 +238,13 @@ func (s *userServer) SetGlobalRecvMessageOpt(ctx context.Context, req *pbUser.Se
 	if err != nil {
 		return nil, err
 	}
-	chat.UserInfoUpdatedNotification(utils.OperationID(ctx), req.UserID, req.UserID)
+	chat.UserInfoUpdatedNotification(tracelog.GetOperationID(ctx), req.UserID, req.UserID)
 	return &resp, nil
 }
 
 func (s *userServer) AccountCheck(ctx context.Context, req *pbUser.AccountCheckReq) (*pbUser.AccountCheckResp, error) {
 	resp := pbUser.AccountCheckResp{}
-	err := token_verify.CheckManagerUserID(ctx, utils.OpUserID(ctx))
+	err := token_verify.CheckManagerUserID(ctx, tracelog.GetOpUserID(ctx))
 	if err != nil {
 		return nil, err
 	}
@@ -272,12 +274,12 @@ func (s *userServer) GetUsers(ctx context.Context, req *pbUser.GetUsersReq) (*pb
 	resp := pbUser.GetUsersResp{}
 	var err error
 	if req.UserID != "" {
-		u, err := s.Take(ctx, req.UserID)
+		u, err := s.Find(ctx, []string{req.UserID})
 		if err != nil {
 			return nil, err
 		}
 		resp.Total = 1
-		u1, err := utils.NewDBUser(u).Convert()
+		u1, err := convert.NewDBUser(u[0]).Convert()
 		if err != nil {
 			return nil, err
 		}
@@ -292,7 +294,7 @@ func (s *userServer) GetUsers(ctx context.Context, req *pbUser.GetUsersReq) (*pb
 		}
 		resp.Total = int32(total)
 		for _, v := range usersDB {
-			u1, err := utils.NewDBUser(v).Convert()
+			u1, err := convert.NewDBUser(v).Convert()
 			if err != nil {
 				return nil, err
 			}
@@ -306,7 +308,7 @@ func (s *userServer) GetUsers(ctx context.Context, req *pbUser.GetUsersReq) (*pb
 		}
 		resp.Total = int32(total)
 		for _, v := range usersDB {
-			u1, err := utils.NewDBUser(v).Convert()
+			u1, err := convert.NewDBUser(v).Convert()
 			if err != nil {
 				return nil, err
 			}
@@ -323,7 +325,7 @@ func (s *userServer) GetUsers(ctx context.Context, req *pbUser.GetUsersReq) (*pb
 	resp.Total = int32(total)
 
 	for _, userDB := range usersDB {
-		u, err := utils.NewDBUser(userDB).Convert()
+		u, err := convert.NewDBUser(userDB).Convert()
 		if err != nil {
 			return nil, err
 		}