sync option

go.mod

@@ -178,4 +178,4 @@ require (
 	gopkg.in/ini.v1 v1.67.0 // indirect
 )
 
-//replace github.com/openimsdk/protocol => /Users/chao/Desktop/project/protocol
+replace github.com/openimsdk/protocol => /Users/chao/Desktop/project/protocol

internal/api/group.go

@@ -180,7 +180,7 @@ func (o *GroupApi) GetIncrementalGroupMemberBatch(c *gin.Context) {
 		}
 		resp.List[req.GroupID] = res
 		changeCount += len(res.Changes) + len(res.DeleteUserIds)
-		if changeCount > int(res.SyncCount)*4 {
+		if changeCount >= int(res.SyncCount) {
 			break
 		}
 	}

internal/rpc/friend/black.go

@@ -21,7 +21,7 @@ import (
 
 	"github.com/openimsdk/open-im-server/v3/pkg/authverify"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/convert"
-	pbfriend "github.com/openimsdk/protocol/friend"
+	pbfriend "github.com/openimsdk/protocol/relation"
 	"github.com/openimsdk/tools/mcontext"
 )
 

internal/rpc/friend/callback.go

@@ -20,7 +20,7 @@ import (
 
 	cbapi "github.com/openimsdk/open-im-server/v3/pkg/callbackstruct"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
-	pbfriend "github.com/openimsdk/protocol/friend"
+	pbfriend "github.com/openimsdk/protocol/relation"
 )
 
 func (s *friendServer) webhookAfterDeleteFriend(ctx context.Context, after *config.AfterConfig, req *pbfriend.DeleteFriendReq) {

internal/rpc/friend/convert.go

@@ -1,26 +0,0 @@
-package friend
-
-import (
-	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/model"
-	"github.com/openimsdk/protocol/friend"
-	"github.com/openimsdk/tools/utils/datautil"
-)
-
-func friendDB2PB(db *model.Friend) *friend.FriendInfo {
-	return &friend.FriendInfo{
-		OwnerUserID:    db.OwnerUserID,
-		FriendUserID:   db.FriendUserID,
-		FriendNickname: db.FriendNickname,
-		FriendFaceURL:  db.FriendFaceURL,
-		Remark:         db.Remark,
-		CreateTime:     db.CreateTime.UnixMilli(),
-		AddSource:      db.AddSource,
-		OperatorUserID: db.OperatorUserID,
-		Ex:             db.Ex,
-		IsPinned:       db.IsPinned,
-	}
-}
-
-func friendsDB2PB(db []*model.Friend) []*friend.FriendInfo {
-	return datautil.Slice(db, friendDB2PB)
-}

internal/rpc/friend/friend.go

@@ -30,7 +30,7 @@ import (
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/controller"
 	"github.com/openimsdk/open-im-server/v3/pkg/rpcclient"
 	"github.com/openimsdk/protocol/constant"
-	pbfriend "github.com/openimsdk/protocol/friend"
+	pbfriend "github.com/openimsdk/protocol/relation"
 	"github.com/openimsdk/protocol/sdkws"
 	"github.com/openimsdk/tools/db/mongoutil"
 	"github.com/openimsdk/tools/discovery"
@@ -50,6 +50,21 @@ type friendServer struct {
 	webhookClient         *webhook.Client
 }
 
+func (s *friendServer) GetIncrementalFriendsApplyTo(ctx context.Context, req *pbfriend.GetIncrementalFriendsApplyToReq) (*pbfriend.GetIncrementalFriendsApplyToResp, error) {
+	//TODO implement me
+	panic("implement me")
+}
+
+func (s *friendServer) GetIncrementalFriendsApplyFrom(ctx context.Context, req *pbfriend.GetIncrementalFriendsApplyFromReq) (*pbfriend.GetIncrementalFriendsApplyFromResp, error) {
+	//TODO implement me
+	panic("implement me")
+}
+
+func (s *friendServer) GetIncrementalBlacks(ctx context.Context, req *pbfriend.GetIncrementalBlacksReq) (*pbfriend.GetIncrementalBlacksResp, error) {
+	//TODO implement me
+	panic("implement me")
+}
+
 type Config struct {
 	RpcConfig     config.Friend
 	RedisConfig   config.Redis
@@ -270,14 +285,24 @@ func (s *friendServer) GetDesignatedFriends(ctx context.Context, req *pbfriend.G
 	if datautil.Duplicate(req.FriendUserIDs) {
 		return nil, errs.ErrArgs.WrapMsg("friend userID repeated")
 	}
-	friends, err := s.friendDatabase.FindFriendsWithError(ctx, req.OwnerUserID, req.FriendUserIDs)
+	friends, err := s.getFriend(ctx, req.OwnerUserID, req.FriendUserIDs)
 	if err != nil {
 		return nil, err
 	}
-	if resp.FriendsInfo, err = convert.FriendsDB2Pb(ctx, friends, s.userRpcClient.GetUsersInfoMap); err != nil {
+	return &pbfriend.GetDesignatedFriendsResp{
+		FriendsInfo: friends,
+	}, nil
+}
+
+func (s *friendServer) getFriend(ctx context.Context, ownerUserID string, friendUserIDs []string) ([]*sdkws.FriendInfo, error) {
+	if len(friendUserIDs) == 0 {
+		return nil, nil
+	}
+	friends, err := s.friendDatabase.FindFriendsWithError(ctx, ownerUserID, friendUserIDs)
+	if err != nil {
 		return nil, err
 	}
-	return resp, nil
+	return convert.FriendsDB2Pb(ctx, friends, s.userRpcClient.GetUsersInfoMap)
 }
 
 // Get the list of friend requests sent out proactively.
@@ -433,6 +458,7 @@ func (s *friendServer) GetSpecifiedFriendsInfo(ctx context.Context, req *pbfrien
 	}
 	return resp, nil
 }
+
 func (s *friendServer) UpdateFriends(
 	ctx context.Context,
 	req *pbfriend.UpdateFriendsReq,

internal/rpc/friend/notification.go

@@ -24,7 +24,7 @@ import (
 	"github.com/openimsdk/open-im-server/v3/pkg/rpcclient"
 	"github.com/openimsdk/open-im-server/v3/pkg/rpcclient/notification"
 	"github.com/openimsdk/protocol/constant"
-	pbfriend "github.com/openimsdk/protocol/friend"
+	pbfriend "github.com/openimsdk/protocol/relation"
 	"github.com/openimsdk/protocol/sdkws"
 	"github.com/openimsdk/tools/mcontext"
 )

internal/rpc/friend/sync.go

@@ -5,63 +5,39 @@ import (
 	"github.com/openimsdk/open-im-server/v3/internal/rpc/incrversion"
 	"github.com/openimsdk/open-im-server/v3/pkg/authverify"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/model"
-	pbfriend "github.com/openimsdk/protocol/friend"
-	"github.com/openimsdk/tools/errs"
+	pbfriend "github.com/openimsdk/protocol/relation"
+	"github.com/openimsdk/protocol/sdkws"
 )
 
-func (s *friendServer) NotificationUserInfoUpdate(ctx context.Context, req *pbfriend.NotificationUserInfoUpdateReq) (*pbfriend.NotificationUserInfoUpdateResp, error) {
-	if req.NewUserInfo == nil {
-		var err error
-		req.NewUserInfo, err = s.userRpcClient.GetUserInfo(ctx, req.UserID)
-		if err != nil {
-			return nil, err
-		}
-	}
-	if req.UserID != req.NewUserInfo.UserID {
-		return nil, errs.ErrArgs.WrapMsg("req.UserID != req.NewUserInfo.UserID")
-	}
-	userIDs, err := s.friendDatabase.FindFriendUserID(ctx, req.UserID)
-	if err != nil {
-		return nil, err
-	}
-	if len(userIDs) > 0 {
-		if err := s.friendDatabase.UpdateFriendUserInfo(ctx, req.UserID, userIDs, req.NewUserInfo.Nickname, req.NewUserInfo.FaceURL); err != nil {
-			return nil, err
-		}
-		s.notificationSender.FriendsInfoUpdateNotification(ctx, req.UserID, userIDs)
-	}
-	return &pbfriend.NotificationUserInfoUpdateResp{}, nil
-}
-
-func (s *friendServer) SearchFriends(ctx context.Context, req *pbfriend.SearchFriendsReq) (*pbfriend.SearchFriendsResp, error) {
-	if err := s.userRpcClient.Access(ctx, req.UserID); err != nil {
-		return nil, err
-	}
-	if req.Keyword == "" {
-		total, friends, err := s.friendDatabase.PageOwnerFriends(ctx, req.UserID, req.Pagination)
-		if err != nil {
-			return nil, err
-		}
-		return &pbfriend.SearchFriendsResp{
-			Total:   total,
-			Friends: friendsDB2PB(friends),
-		}, nil
-	}
-	total, friends, err := s.friendDatabase.SearchFriend(ctx, req.UserID, req.Keyword, req.Pagination)
-	if err != nil {
-		return nil, err
-	}
-	return &pbfriend.SearchFriendsResp{
-		Total:   total,
-		Friends: friendsDB2PB(friends),
-	}, nil
-}
+//func (s *friendServer) SearchFriends(ctx context.Context, req *pbfriend.SearchFriendsReq) (*pbfriend.SearchFriendsResp, error) {
+//	if err := s.userRpcClient.Access(ctx, req.UserID); err != nil {
+//		return nil, err
+//	}
+//	if req.Keyword == "" {
+//		total, friends, err := s.friendDatabase.PageOwnerFriends(ctx, req.UserID, req.Pagination)
+//		if err != nil {
+//			return nil, err
+//		}
+//		return &pbfriend.SearchFriendsResp{
+//			Total:   total,
+//			Friends: friendsDB2PB(friends),
+//		}, nil
+//	}
+//	total, friends, err := s.friendDatabase.SearchFriend(ctx, req.UserID, req.Keyword, req.Pagination)
+//	if err != nil {
+//		return nil, err
+//	}
+//	return &pbfriend.SearchFriendsResp{
+//		Total:   total,
+//		Friends: friendsDB2PB(friends),
+//	}, nil
+//}
 
 func (s *friendServer) GetIncrementalFriends(ctx context.Context, req *pbfriend.GetIncrementalFriendsReq) (*pbfriend.GetIncrementalFriendsResp, error) {
 	if err := authverify.CheckAccessV3(ctx, req.UserID, s.config.Share.IMAdminUserID); err != nil {
 		return nil, err
 	}
-	opt := incrversion.Option[*pbfriend.FriendInfo, pbfriend.GetIncrementalFriendsResp]{
+	opt := incrversion.Option[*sdkws.FriendInfo, pbfriend.GetIncrementalFriendsResp]{
 		Ctx:             ctx,
 		VersionKey:      req.UserID,
 		VersionID:       req.VersionID,
@@ -70,15 +46,11 @@ func (s *friendServer) GetIncrementalFriends(ctx context.Context, req *pbfriend.
 		Version:         s.friendDatabase.FindFriendIncrVersion,
 		CacheMaxVersion: s.friendDatabase.FindMaxFriendVersionCache,
 		SortID:          s.friendDatabase.FindSortFriendUserIDs,
-		Find: func(ctx context.Context, ids []string) ([]*pbfriend.FriendInfo, error) {
-			friends, err := s.friendDatabase.FindFriendsWithError(ctx, req.UserID, ids)
-			if err != nil {
-				return nil, err
-			}
-			return friendsDB2PB(friends), nil
+		Find: func(ctx context.Context, ids []string) ([]*sdkws.FriendInfo, error) {
+			return s.getFriend(ctx, req.UserID, ids)
 		},
-		ID: func(elem *pbfriend.FriendInfo) string { return elem.FriendUserID },
-		Resp: func(version *model.VersionLog, delIDs []string, list []*pbfriend.FriendInfo, full bool) *pbfriend.GetIncrementalFriendsResp {
+		ID: func(elem *sdkws.FriendInfo) string { return elem.FriendUser.UserID },
+		Resp: func(version *model.VersionLog, delIDs []string, list []*sdkws.FriendInfo, full bool) *pbfriend.GetIncrementalFriendsResp {
 			return &pbfriend.GetIncrementalFriendsResp{
 				VersionID:     version.ID.Hex(),
 				Version:       uint64(version.Version),

internal/rpc/group/sync.go

@@ -9,11 +9,6 @@ import (
 	"github.com/openimsdk/protocol/sdkws"
 )
 
-func (s *groupServer) SearchGroupMember(ctx context.Context, req *pbgroup.SearchGroupMemberReq) (*pbgroup.SearchGroupMemberResp, error) {
-	//TODO implement me
-	panic("implement me")
-}
-
 func (s *groupServer) GetIncrementalGroupMember(ctx context.Context, req *pbgroup.GetIncrementalGroupMemberReq) (*pbgroup.GetIncrementalGroupMemberResp, error) {
 	opt := incrversion.Option[*sdkws.GroupMemberFullInfo, pbgroup.GetIncrementalGroupMemberResp]{
 		Ctx:             ctx,

internal/rpc/user/user.go

@@ -16,7 +16,6 @@ package user
 
 import (
 	"context"
-	"errors"
 	"github.com/openimsdk/open-im-server/v3/internal/rpc/friend"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/cache/redis"
@@ -24,12 +23,9 @@ import (
 	tablerelation "github.com/openimsdk/open-im-server/v3/pkg/common/storage/model"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/webhook"
 	"github.com/openimsdk/open-im-server/v3/pkg/localcache"
-	friendpb "github.com/openimsdk/protocol/friend"
-	"github.com/openimsdk/protocol/group"
 	"github.com/openimsdk/tools/db/redisutil"
 	"math/rand"
 	"strings"
-	"sync"
 	"time"
 
 	"github.com/openimsdk/open-im-server/v3/pkg/authverify"
@@ -135,29 +131,26 @@ func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbuser.UpdateUserI
 	if err := s.webhookBeforeUpdateUserInfo(ctx, &s.config.WebhooksConfig.BeforeUpdateUserInfo, req); err != nil {
 		return nil, err
 	}
+
 	data := convert.UserPb2DBMap(req.UserInfo)
-	oldUser, err := s.db.GetUserByID(ctx, req.UserInfo.UserID)
-	if err != nil {
+	if err := s.db.UpdateByMap(ctx, req.UserInfo.UserID, data); err != nil {
 		return nil, err
 	}
-	if err := s.db.UpdateByMap(ctx, req.UserInfo.UserID, data); err != nil {
+	s.friendNotificationSender.UserInfoUpdatedNotification(ctx, req.UserInfo.UserID)
+	friends, err := s.friendRpcClient.GetFriendIDs(ctx, req.UserInfo.UserID)
+	if err != nil {
 		return nil, err
 	}
-	//s.friendNotificationSender.UserInfoUpdatedNotification(ctx, req.UserInfo.UserID)
-	//friends, err := s.friendRpcClient.GetFriendIDs(ctx, req.UserInfo.UserID)
-	//if err != nil {
-	//	return nil, err
-	//}
-	//if req.UserInfo.Nickname != "" || req.UserInfo.FaceURL != "" {
-	//	if err = s.NotificationUserInfoUpdate(ctx, req.UserInfo.UserID,oldUser); err != nil {
-	//		return nil, err
-	//	}
-	//}
-	//for _, friendID := range friends {
-	//	s.friendNotificationSender.FriendInfoUpdatedNotification(ctx, req.UserInfo.UserID, friendID)
-	//}
+	if req.UserInfo.Nickname != "" || req.UserInfo.FaceURL != "" {
+		if err = s.groupRpcClient.NotificationUserInfoUpdate(ctx, req.UserInfo.UserID); err != nil {
+			return nil, err
+		}
+	}
+	for _, friendID := range friends {
+		s.friendNotificationSender.FriendInfoUpdatedNotification(ctx, req.UserInfo.UserID, friendID)
+	}
 	s.webhookAfterUpdateUserInfo(ctx, &s.config.WebhooksConfig.AfterUpdateUserInfo, req)
-	if err = s.NotificationUserInfoUpdate(ctx, req.UserInfo.UserID, oldUser); err != nil {
+	if err = s.groupRpcClient.NotificationUserInfoUpdate(ctx, req.UserInfo.UserID); err != nil {
 		return nil, err
 	}
 	return resp, nil
@@ -171,29 +164,25 @@ func (s *userServer) UpdateUserInfoEx(ctx context.Context, req *pbuser.UpdateUse
 	if err = s.webhookBeforeUpdateUserInfoEx(ctx, &s.config.WebhooksConfig.BeforeUpdateUserInfoEx, req); err != nil {
 		return nil, err
 	}
-	oldUser, err := s.db.GetUserByID(ctx, req.UserInfo.UserID)
-	if err != nil {
-		return nil, err
-	}
 	data := convert.UserPb2DBMapEx(req.UserInfo)
 	if err = s.db.UpdateByMap(ctx, req.UserInfo.UserID, data); err != nil {
 		return nil, err
 	}
-	//s.friendNotificationSender.UserInfoUpdatedNotification(ctx, req.UserInfo.UserID)
-	//friends, err := s.friendRpcClient.GetFriendIDs(ctx, req.UserInfo.UserID)
-	//if err != nil {
-	//	return nil, err
-	//}
-	//if req.UserInfo.Nickname != nil || req.UserInfo.FaceURL != nil {
-	//	if err := s.NotificationUserInfoUpdate(ctx, req.UserInfo.UserID); err != nil {
-	//		return nil, err
-	//	}
-	//}
-	//for _, friendID := range friends {
-	//	s.friendNotificationSender.FriendInfoUpdatedNotification(ctx, req.UserInfo.UserID, friendID)
-	//}
+	s.friendNotificationSender.UserInfoUpdatedNotification(ctx, req.UserInfo.UserID)
+	friends, err := s.friendRpcClient.GetFriendIDs(ctx, req.UserInfo.UserID)
+	if err != nil {
+		return nil, err
+	}
+	if req.UserInfo.Nickname != nil || req.UserInfo.FaceURL != nil {
+		if err := s.groupRpcClient.NotificationUserInfoUpdate(ctx, req.UserInfo.UserID); err != nil {
+			return nil, err
+		}
+	}
+	for _, friendID := range friends {
+		s.friendNotificationSender.FriendInfoUpdatedNotification(ctx, req.UserInfo.UserID, friendID)
+	}
 	s.webhookAfterUpdateUserInfoEx(ctx, &s.config.WebhooksConfig.AfterUpdateUserInfoEx, req)
-	if err := s.NotificationUserInfoUpdate(ctx, req.UserInfo.UserID, oldUser); err != nil {
+	if err := s.groupRpcClient.NotificationUserInfoUpdate(ctx, req.UserInfo.UserID); err != nil {
 		return nil, err
 	}
 	return resp, nil
@@ -695,40 +684,10 @@ func (s *userServer) userModelToResp(users []*tablerelation.User, pagination pag
 	return &pbuser.SearchNotificationAccountResp{Total: total, NotificationAccounts: notificationAccounts}
 }
 
-func (s *userServer) NotificationUserInfoUpdate(ctx context.Context, userID string, oldUser *tablerelation.User) error {
-	user, err := s.db.GetUserByID(ctx, userID)
+func (s *userServer) SortQuery(ctx context.Context, req *pbuser.SortQueryReq) (*pbuser.SortQueryResp, error) {
+	users, err := s.db.SortQuery(ctx, req.UserIDName, req.Asc)
 	if err != nil {
-		return err
+		return nil, err
 	}
-	if *user == *oldUser {
-		return nil
-	}
-	s.friendNotificationSender.UserInfoUpdatedNotification(ctx, userID)
-	if user.Nickname == oldUser.Nickname && user.FaceURL == oldUser.FaceURL {
-		return nil
-	}
-	oldUserInfo := convert.UserDB2Pb(oldUser)
-	newUserInfo := convert.UserDB2Pb(user)
-	var wg sync.WaitGroup
-	var es [2]error
-	wg.Add(len(es))
-	go func() {
-		defer wg.Done()
-		_, es[0] = s.groupRpcClient.Client.NotificationUserInfoUpdate(ctx, &group.NotificationUserInfoUpdateReq{
-			UserID:      userID,
-			OldUserInfo: oldUserInfo,
-			NewUserInfo: newUserInfo,
-		})
-	}()
-
-	go func() {
-		defer wg.Done()
-		_, es[1] = s.friendRpcClient.Client.NotificationUserInfoUpdate(ctx, &friendpb.NotificationUserInfoUpdateReq{
-			UserID:      userID,
-			OldUserInfo: oldUserInfo,
-			NewUserInfo: newUserInfo,
-		})
-	}()
-	wg.Wait()
-	return errors.Join(es[:]...)
+	return &pbuser.SortQueryResp{Users: convert.UsersDB2Pb(users)}, nil
 }

pkg/common/storage/cache/group.go

@@ -46,7 +46,6 @@ type GroupCache interface {
 	GetGroupMemberInfo(ctx context.Context, groupID, userID string) (groupMember *model.GroupMember, err error)
 	GetGroupMembersInfo(ctx context.Context, groupID string, userID []string) (groupMembers []*model.GroupMember, err error)
 	GetAllGroupMembersInfo(ctx context.Context, groupID string) (groupMembers []*model.GroupMember, err error)
-	GetGroupMembersPage(ctx context.Context, groupID string, userID []string, showNumber, pageNumber int32) (total uint32, groupMembers []*model.GroupMember, err error)
 	FindGroupMemberUser(ctx context.Context, groupIDs []string, userID string) ([]*model.GroupMember, error)
 
 	GetGroupRoleLevelMemberIDs(ctx context.Context, groupID string, roleLevel int32) ([]string, error)

pkg/common/storage/cache/redis/group.go

@@ -27,7 +27,6 @@ import (
 	"github.com/openimsdk/protocol/constant"
 	"github.com/openimsdk/tools/errs"
 	"github.com/openimsdk/tools/log"
-	"github.com/openimsdk/tools/utils/datautil"
 	"github.com/redis/go-redis/v9"
 	"time"
 )
@@ -296,26 +295,6 @@ func (g *GroupCacheRedis) GetGroupMembersInfo(ctx context.Context, groupID strin
 	})
 }
 
-func (g *GroupCacheRedis) GetGroupMembersPage(
-	ctx context.Context,
-	groupID string,
-	userIDs []string,
-	showNumber, pageNumber int32,
-) (total uint32, groupMembers []*model.GroupMember, err error) {
-	groupMemberIDs, err := g.GetGroupMemberIDs(ctx, groupID)
-	if err != nil {
-		return 0, nil, err
-	}
-	if userIDs != nil {
-		userIDs = datautil.BothExist(userIDs, groupMemberIDs)
-	} else {
-		userIDs = groupMemberIDs
-	}
-	groupMembers, err = g.GetGroupMembersInfo(ctx, groupID, datautil.Paginate(userIDs, int(showNumber), int(showNumber)))
-
-	return uint32(len(userIDs)), groupMembers, err
-}
-
 func (g *GroupCacheRedis) GetAllGroupMembersInfo(ctx context.Context, groupID string) (groupMembers []*model.GroupMember, err error) {
 	groupMemberIDs, err := g.GetGroupMemberIDs(ctx, groupID)
 	if err != nil {

pkg/common/storage/controller/friend.go

@@ -86,9 +86,7 @@ type FriendDatabase interface {
 
 	FindFriendUserID(ctx context.Context, friendUserID string) ([]string, error)
 
-	UpdateFriendUserInfo(ctx context.Context, friendUserID string, ownerUserID []string, nickname string, faceURL string) error
-
-	SearchFriend(ctx context.Context, ownerUserID, keyword string, pagination pagination.Pagination) (int64, []*model.Friend, error)
+	//SearchFriend(ctx context.Context, ownerUserID, keyword string, pagination pagination.Pagination) (int64, []*model.Friend, error)
 }
 
 type friendDatabase struct {
@@ -378,15 +376,6 @@ func (f *friendDatabase) FindFriendUserID(ctx context.Context, friendUserID stri
 	return f.friend.FindFriendUserID(ctx, friendUserID)
 }
 
-func (f *friendDatabase) UpdateFriendUserInfo(ctx context.Context, friendUserID string, ownerUserIDs []string, nickname string, faceURL string) error {
-	return f.tx.Transaction(ctx, func(ctx context.Context) error {
-		if err := f.friend.UpdateFriendUserInfo(ctx, friendUserID, nickname, faceURL); err != nil {
-			return err
-		}
-		return f.cache.DelOwner(friendUserID, ownerUserIDs).DelMaxFriendVersion(ownerUserIDs...).ChainExecDel(ctx)
-	})
-}
-
-func (f *friendDatabase) SearchFriend(ctx context.Context, ownerUserID, keyword string, pagination pagination.Pagination) (int64, []*model.Friend, error) {
-	return f.friend.SearchFriend(ctx, ownerUserID, keyword, pagination)
-}
+//func (f *friendDatabase) SearchFriend(ctx context.Context, ownerUserID, keyword string, pagination pagination.Pagination) (int64, []*model.Friend, error) {
+//	return f.friend.SearchFriend(ctx, ownerUserID, keyword, pagination)
+//}

pkg/common/storage/controller/user.go

@@ -60,6 +60,8 @@ type UserDatabase interface {
 	CountTotal(ctx context.Context, before *time.Time) (int64, error)
 	// CountRangeEverydayTotal Get the user increment in the range
 	CountRangeEverydayTotal(ctx context.Context, start time.Time, end time.Time) (map[string]int64, error)
+
+	SortQuery(ctx context.Context, userIDName map[string]string, asc bool) ([]*model.User, error)
 	// SubscribeUsersStatus Subscribe a user's presence status
 	SubscribeUsersStatus(ctx context.Context, userID string, userIDs []string) error
 	// UnsubscribeUsersStatus unsubscribe a user's presence status
@@ -210,6 +212,10 @@ func (u *userDatabase) CountRangeEverydayTotal(ctx context.Context, start time.T
 	return u.userDB.CountRangeEverydayTotal(ctx, start, end)
 }
 
+func (u *userDatabase) SortQuery(ctx context.Context, userIDName map[string]string, asc bool) ([]*model.User, error) {
+	return u.userDB.SortQuery(ctx, userIDName, asc)
+}
+
 // SubscribeUsersStatus Subscribe or unsubscribe a user's presence status.
 func (u *userDatabase) SubscribeUsersStatus(ctx context.Context, userID string, userIDs []string) error {
 	err := u.mongoDB.AddSubscriptionList(ctx, userID, userIDs)

pkg/common/storage/database/friend.go

@@ -52,9 +52,7 @@ type Friend interface {
 
 	FindFriendUserID(ctx context.Context, friendUserID string) ([]string, error)
 
-	UpdateFriendUserInfo(ctx context.Context, friendUserID string, nickname string, faceURL string) error
-
-	SearchFriend(ctx context.Context, ownerUserID, keyword string, pagination pagination.Pagination) (int64, []*model.Friend, error)
+	//SearchFriend(ctx context.Context, ownerUserID, keyword string, pagination pagination.Pagination) (int64, []*model.Friend, error)
 
 	FindOwnerFriendUserIds(ctx context.Context, ownerUserID string, limit int) ([]string, error)
 }

pkg/common/storage/database/mgo/friend.go

@@ -53,7 +53,7 @@ func NewFriendMongo(db *mongo.Database) (database.Friend, error) {
 }
 
 func (f *FriendMgo) friendSort() any {
-	return bson.D{{"is_pinned", -1}, {"friend_nickname", 1}, {"create_time", 1}}
+	return bson.D{{"is_pinned", -1}, {"create_time", 1}}
 }
 
 // Create inserts multiple friend records.
@@ -168,7 +168,7 @@ func (f *FriendMgo) FindInWhoseFriends(ctx context.Context, friendUserID string,
 // FindFriendUserIDs retrieves a list of friend user IDs for a given owner.
 func (f *FriendMgo) FindFriendUserIDs(ctx context.Context, ownerUserID string) ([]string, error) {
 	filter := bson.M{"owner_user_id": ownerUserID}
-	return mongoutil.Find[string](ctx, f.coll, filter, options.Find().SetProjection(bson.M{"_id": 0, "friend_user_id": 1}))
+	return mongoutil.Find[string](ctx, f.coll, filter, options.Find().SetProjection(bson.M{"_id": 0, "friend_user_id": 1}).SetSort(f.friendSort()))
 }
 
 func (f *FriendMgo) UpdateFriends(ctx context.Context, ownerUserID string, friendUserIDs []string, val map[string]any) error {
@@ -204,25 +204,17 @@ func (f *FriendMgo) FindFriendUserID(ctx context.Context, friendUserID string) (
 	return mongoutil.Find[string](ctx, f.coll, filter, options.Find().SetProjection(bson.M{"_id": 0, "owner_user_id": 1}).SetSort(f.friendSort()))
 }
 
-func (f *FriendMgo) UpdateFriendUserInfo(ctx context.Context, friendUserID string, nickname string, faceURL string) error {
-	filter := bson.M{
-		"friend_user_id": friendUserID,
-	}
-	_, err := mongoutil.UpdateMany(ctx, f.coll, filter, bson.M{"$set": bson.M{"nickname": nickname, "face_url": faceURL}})
-	return err
-}
-
-func (f *FriendMgo) SearchFriend(ctx context.Context, ownerUserID, keyword string, pagination pagination.Pagination) (int64, []*model.Friend, error) {
-	filter := bson.M{
-		"owner_user_id": ownerUserID,
-	}
-	if keyword != "" {
-		filter["$or"] = []bson.M{
-			{"remark": bson.M{"$regex": keyword, "$options": "i"}},
-			{"nickname": bson.M{"$regex": keyword, "$options": "i"}},
-			{"friend_user_id": bson.M{"$regex": keyword, "$options": "i"}},
-		}
-	}
-	opt := options.Find().SetSort(f.friendSort())
-	return mongoutil.FindPage[*model.Friend](ctx, f.coll, filter, pagination, opt)
-}
+//func (f *FriendMgo) SearchFriend(ctx context.Context, ownerUserID, keyword string, pagination pagination.Pagination) (int64, []*model.Friend, error) {
+//	filter := bson.M{
+//		"owner_user_id": ownerUserID,
+//	}
+//	if keyword != "" {
+//		filter["$or"] = []bson.M{
+//			{"remark": bson.M{"$regex": keyword, "$options": "i"}},
+//			{"nickname": bson.M{"$regex": keyword, "$options": "i"}},
+//			{"friend_user_id": bson.M{"$regex": keyword, "$options": "i"}},
+//		}
+//	}
+//	opt := options.Find().SetSort(f.friendSort())
+//	return mongoutil.FindPage[*model.Friend](ctx, f.coll, filter, pagination, opt)
+//}

pkg/common/storage/database/mgo/user.go

@@ -319,3 +319,69 @@ func (u *UserMgo) CountRangeEverydayTotal(ctx context.Context, start time.Time,
 	}
 	return res, nil
 }
+
+func (u *UserMgo) SortQuery(ctx context.Context, userIDName map[string]string, asc bool) ([]*model.User, error) {
+	if len(userIDName) == 0 {
+		return nil, nil
+	}
+	userIDs := make([]string, 0, len(userIDName))
+	attached := make(map[string]string)
+	for userID, name := range userIDName {
+		userIDs = append(userIDs, userID)
+		if name == "" {
+			continue
+		}
+		attached[userID] = name
+	}
+	var sortValue int
+	if asc {
+		sortValue = 1
+	} else {
+		sortValue = -1
+	}
+	if len(attached) == 0 {
+		filter := bson.M{"user_id": bson.M{"$in": userIDs}}
+		opt := options.Find().SetSort(bson.M{"nickname": sortValue})
+		return mongoutil.Find[*model.User](ctx, u.coll, filter, opt)
+	}
+	pipeline := []bson.M{
+		{
+			"$match": bson.M{
+				"user_id": bson.M{"$in": userIDs},
+			},
+		},
+		{
+			"$addFields": bson.M{
+				"_query_sort_name": bson.M{
+					"$arrayElemAt": []any{
+						bson.M{
+							"$filter": bson.M{
+								"input": bson.M{
+									"$objectToArray": attached,
+								},
+								"as": "item",
+								"cond": bson.M{
+									"$eq": []any{"$$item.k", "$user_id"},
+								},
+							},
+						},
+						0,
+					},
+				},
+			},
+		},
+		{
+			"$addFields": bson.M{
+				"_query_sort_name": bson.M{
+					"$ifNull": []any{"$_query_sort_name.v", "$nickname"},
+				},
+			},
+		},
+		{
+			"$sort": bson.M{
+				"_query_sort_name": sortValue,
+			},
+		},
+	}
+	return mongoutil.Aggregate[*model.User](ctx, u.coll, pipeline)
+}

pkg/common/storage/database/user.go

@@ -39,6 +39,9 @@ type User interface {
 	CountTotal(ctx context.Context, before *time.Time) (count int64, err error)
 	// Get user total quantity every day
 	CountRangeEverydayTotal(ctx context.Context, start time.Time, end time.Time) (map[string]int64, error)
+
+	SortQuery(ctx context.Context, userIDName map[string]string, asc bool) ([]*model.User, error)
+
 	// CRUD user command
 	AddUserCommand(ctx context.Context, userID string, Type int32, UUID string, value string, ex string) error
 	DeleteUserCommand(ctx context.Context, userID string, Type int32, UUID string) error