python中带有嵌套查询集的Django排序查询集

我有一个带有嵌套queryset（成员资格）和嵌套queryset（信用）的queryset（组）。这是输出：

group = [
    {
        "name": "Group2",
        "memberships": [
            {
                "username": "test1",
                "credits": [
                    {
                        "credits": 1000,
                        "year": 2020,
                        "week": 42,
                        "game_count": 1,
                        "last_game_credits": 10,
                    }
                ],
            },
            {
                "username": "test2",
                "credits": [
                    {
                        "credits": 1500,
                        "year": 2020,
                        "week": 42,
                        "game_count": 1,
                        "last_game_credits": 0,
                    }
                ],
            },
            {
                "username": "test",
                "credits": [
                    {
                        "credits": 1000,
                        "year": 2020,
                        "week": 42,
                        "game_count": 1,
                        "last_game_credits": 0,
                    }
                ],
               
            }
        ]
    }
]

我想按以下方式对会员资格进行排名：

class GroupSet(generics.ListAPIView):
    lookup_field = 'name'
    serializer_class = GroupSerializer

    def get_queryset(self):

        year = self.request.query_params.get('year', None)
        week = self.request.query_params.get('week', None)
        name = self.request.query_params.get('name', None)

        if name and week and year is not None:

            weekStr = str(week)
            yearStr = str(year)
            yearweekStr = yearStr + '-W' + weekStr
            r = datetime.datetime.strptime(yearweekStr + '-7', "%G-W%V-%u").date()

            prefetchCredits = Prefetch('user__credits', queryset=Credits.objects.filter(year=year, week=week))

            prefetchMemberships = Prefetch('membership_set', queryset=Membership.objects.prefetch_related(prefetchCredits))

            sortedMemberships = sorted(prefetchMemberships.queryset, key=lambda e: (e.user.credits.all()[0].credits, e.user.credits.all()[0].game_count, e.user.credits.all()[0].last_game_credits),
                         reverse=True)

            group = Group.objects.filter(name__iexact=name)

            newGroup = [
                {
                    'name': group[0].name,
                    'id': group[0].id,
                    'membership_set': sortedMemberships

                }
            ]

            return newGroup

贷项（金额）

游戏计数（数量）

最后一场比赛积分（金额）

因此，如果两名玩家的积分相等，则游戏点数最高的玩家获胜。如果相同，则最后一场比赛积分最高者获胜

我希望返回相同的结构

Models: 
class Group(models.Model):
    name = models.CharField(max_length=128, unique=True)
    members = models.ManyToManyField(settings.AUTH_USER_MODEL, related_name="memberships", 
    through='Membership')
    
class Membership(models.Model):
    user = models.ForeignKey(settings.AUTH_USER_MODEL, related_name="membership", 
    on_delete=models.CASCADE)
    group = models.ForeignKey(Group, on_delete=models.CASCADE)
    
class Credits(models.Model):
    credits = models.IntegerField()
    year = models.IntegerField(default=date.today().isocalendar()[0])
    week = models.IntegerField(default=date.today().isocalendar()[1])
    user = models.ForeignKey(settings.AUTH_USER_MODEL, related_name="credits", 
    on_delete=models.CASCADE)
    game_count = models.IntegerField(default=0)
    last_game_credits = models.IntegerField(null=True)

class User(AbstractBaseUser, PermissionsMixin):
    email = models.EmailField(max_length=255, unique=True)
    username = NameField(max_length=25, unique=True,  

视图：

不幸的是，它无法使用。在Credits字段上添加注释，然后使用order_by。出于某种原因，将使用de DB中的所有Credits对象，而不是带有年份和周的过滤预取对象。因此，预取被忽略

---

我的问题是如何按照上面在python中描述的顺序/排序。由于嵌套的查询集和成员模型是多对多的，因此我不断收到错误。

我通过以下方式获得了所需的结果：

class GroupSet(generics.ListAPIView):
    lookup_field = 'name'
    serializer_class = GroupSerializer

    def get_queryset(self):

        year = self.request.query_params.get('year', None)
        week = self.request.query_params.get('week', None)
        name = self.request.query_params.get('name', None)

        if name and week and year is not None:

            weekStr = str(week)
            yearStr = str(year)
            yearweekStr = yearStr + '-W' + weekStr
            r = datetime.datetime.strptime(yearweekStr + '-7', "%G-W%V-%u").date()

            prefetchCredits = Prefetch('user__credits', queryset=Credits.objects.filter(year=year, week=week))

            prefetchMemberships = Prefetch('membership_set', queryset=Membership.objects.prefetch_related(prefetchCredits))

            sortedMemberships = sorted(prefetchMemberships.queryset, key=lambda e: (e.user.credits.all()[0].credits, e.user.credits.all()[0].game_count, e.user.credits.all()[0].last_game_credits),
                         reverse=True)

            group = Group.objects.filter(name__iexact=name)

            newGroup = [
                {
                    'name': group[0].name,
                    'id': group[0].id,
                    'membership_set': sortedMemberships

                }
            ]

            return newGroup

使用预取的信用卡检索成员资格后，将对成员进行排序。这将创建一个列表，因此在调用组对象时，它不能用于预回迁\u相关。因此，newGroup对象由来自group和storedMemberships变量的数据组成

如果有人有一个不那么诡计多端的解决方案，我很乐意听到