Django，组合两个查询集并通过一个通用的m2m字段对它们进行排序

Question

我有两个模型：

class Course(models.Model):
    course_type = models.ForeignKey(CourseType, 
                                    related_name='course_type_courses',
                                    on_delete=models.PROTECT)
    name = models.CharField(max_length=255)
    course_category = models.ForeignKey(CourseCategory,
                                        related_name='category_courses',
                                        on_delete=models.PROTECT)
    course_format = models.ForeignKey(CourseFormat, 
                                      related_name='format_courses',
                                      on_delete=models.PROTECT)
    school = models.ForeignKey(School,
                               related_name='school_courses',
                               blank=True,
                               null=True,
                               on_delete=models.PROTECT)
    room = models.IntegerField(blank=True,
                               null=True)
    active_status = models.IntegerField(default=1,
                                        blank=True,
                                        null=True)
    description = models.CharField(max_length=255,
                                   blank=True,
                                   null=True)
    schedule = models.ManyToManyField(Schedule)
    sessions = models.IntegerField(default=0)
    progress = models.CharField(max_length=100,
                                default="P1W1")
    start_date = models.DateField(blank=True,
                                  null=True)

class Demo(models.Model):
    course_category = models.ForeignKey(CourseCategory, related_name='category_demos', on_delete=models.PROTECT)
    date = models.DateField(blank=True, null=True)
    schedule = models.ManyToManyField(Schedule)
    weekly = models.BooleanField(default=False)
    pm = models.ForeignKey(settings.AUTH_USER_MODEL, related_name='pm_demos', on_delete=models.PROTECT)
    cf = models.ForeignKey(settings.AUTH_USER_MODEL, related_name='cf_demos', on_delete=models.PROTECT)
    active_status = models.BooleanField(default=1)
    demo = models.BooleanField(default=1)

两者都与“计划”模型具有共同的m2m关系：

class Schedule(models.Model):
    day = models.ForeignKey(Weekdays, on_delete=models.PROTECT)
    start_time = models.TimeField()
    end_time = models.TimeField()

我还有一张表格将用户链接到课程

class UserCourse(models.Model):
    user = models.ForeignKey(settings.AUTH_USER_MODEL, related_name='user_courses', on_delete=models.PROTECT)
    course = models.ForeignKey(Course, related_name='course_user_courses', on_delete=models.PROTECT)

我想检索与一个用户相关的所有课程：

def courses(self):
        from holos_apps.holos.models import Course
        all_user_courses = self.user_courses.all().values_list('course', flat=True)

        return Course.objects.filter(id__in=all_user_courses).distinct().order_by('schedule__day',
                                                                                  'schedule__start_time')

 def active_courses(self):
        return self.courses().exclude(active_status=0)

以及与一个用户关联的所有演示

def demos(self):
        if self.user_type.name == 'PM':
            return self.pm_demos.all().distinct().order_by('schedule__day',
                                                           'schedule__start_time')
        return self.cf_demos.all().distinct().order_by('schedule__day',
                                                       'schedule__start_time')

而且我想合并它们，但要在预定的日期和预定的开始时间之前对其进行排序。

def all_courses(self):
        courses = self.active_courses()
        demos = self.demos()
        from itertools import chain
        result_list = sorted(
            chain(courses, demos),
            key=lambda instance: instance.schedule.all.start_time)
        return result_list

很遗憾，链上的钥匙在m2m字段上不起作用。知道如何组合这些查询集吗？

Answer 1

我的问题没有多大意义。如果存在一个m2m字段，则可以将一个实例绑定到m2m字段中的两个实例。在这种情况下，您如何知道要选择m2m字段的哪个实例来订购列表？我们可以选择第一个，但并不能真正满足我的需求。

我重新考虑了这个问题，并意识到我想列出的清单不是课程的之一，而是按其时隙排列的，而是按其时隙排列的。即m2m类的实例列表。