Django存储实际可用性并查询新预订的可用时间表

Question

在应用程序中，有两种类型的用户： Student和Mentor

1. 作为mentor用户类型，我可以设置每周的可用性
2. 作为student用户类型，我可以看到mentor可用性

============================================================

因此，我在WeekDay和AvailableHour模型中存储基于周日的用户可用性

DAYS_OF_WEEK = (
    (0, 'Monday'),
    (1, 'Tuesday'),
    (2, 'Wednesday'),
    (3, 'Thursday'),
    (4, 'Friday'),
    (5, 'Saturday'),
    (6, 'Sunday'),
)
        
class WeekDay(models.Model):
    mentor = models.ForeignKey(
        User,
        on_delete=models.CASCADE,
        related_name="weekday"
    )
    weekday = models.IntegerField(choices=DAYS_OF_WEEK)
    

class AvailableHour(models.Model): #Based on weekday
    weekday = models.ForeignKey(
        WeekDay,
        on_delete=models.CASCADE,
        related_name="available_hour"
    )
    from_hour = models.TimeField()
    to_hour = models.TimeField()

1. 作为用户类型student，我只能在mentor可用小时内预订会话

因此，当学生预订课程时，我们将信息存储在模型下面

 class BookingSession(models.Model):
   student = models.ForeignKey(
        User,
        on_delete=models.CASCADE,
        related_name="student_booking"
    )
    mentor = models.ForeignKey(
        User,
        on_delete=models.CASCADE,
        related_name="mentor_booking"
    )
    date = models.DateField()
    
    from_hour = models.TimeField()
    to_hour = models.TimeField()

那么现在有什么问题吗？

因为我们有用户AvailableHour，所以一旦学生预订了导师课程，那么导师档案中指定的时间范围是不可用的，对吗？这样其他学生就可以看到导师的实际可用性

所以你知道，如果我们从AvailableHour获得queryset，这并不意味着如果任何指定的时间范围已经预订，并且预订的时间已经存储在BookingSession模型中，那么tutor在该时间内可用

如果在指定的工作日BookingSession中存在开始时间和结束时间，我想排除AvailableHour的记录

我想向学生展示，导师的实际可用性是什么

比如AvailableHour不能被存储，如果在BookingSession已经有预订，那么实际可用。你知道的

假设我在BookingSession表中有数据

booked_sesson = [
    {'date': '2021-08-02','from_hour': '12:30', 'to_hour': '12:15' }, # monday
    {'date': '2021-08-04','from_hour': '02:30', 'to_hour': '03:15' }, # Wednesday
]

以及下面的{}和{}可用性表数据

available_based_on_weekday = [
    {
        "weekday": 1, 'opening_hour_time': [ # monday
            {'from_hour': '12:30', 'to_hour': '12:15'},
            {'from_hour': '12:30', 'to_hour': '12:15'},
            {'from_hour': '12:30', 'to_hour': '12:15'}
        ]
    },
    {
        "weekday": 7, 'opening_hour_time': [ # Saturday
            {'from_hour': '13:30', 'to_hour': '15:15'},
            {'from_hour': '15:30', 'to_hour': '16:15'},
            {'from_hour': '19:30', 'to_hour': '20:15'},
            {'from_hour': '23:30', 'to_hour': '23:45'}
        ]
    },
    {
        "weekday": 3, 'opening_hour_time': [ # Wednesday
            {'from_hour': '02:30', 'to_hour': '03:30'},
            {'from_hour': '17:30', 'to_hour': '18:15'},
            {'from_hour': '19:30', 'to_hour': '20:15'},
            {'from_hour': '21:30', 'to_hour': '22:30'}
        ]
    }
]

我期望的输出结果是什么？ 在查询之后，我期望得到这些输出，并应逐月进行查询：

actual_availability = [
     {
         'date': '2021-08-01',
         'available': []
     },
     {
         'date': '2021-08-02',
         'available': [
            {'from_hour': '12:30', 'to_hour': '12:15'},
            {'from_hour': '12:30', 'to_hour': '12:15'}
         ]
     },
     {
         'date': '2021-08-03',
         'available': []
     },
     {
         'date': '2021-08-04',
         'available': [
            {'from_hour': '03:15', 'to_hour': '03:30'},
            {'from_hour': '17:30', 'to_hour': '18:15'},
            {'from_hour': '19:30', 'to_hour': '20:15'},
            {'from_hour': '21:30', 'to_hour': '22:30'}
         ]
     },
     {
         'date': '2021-08-05',
         'available': []
     },
     {
         'date': '2021-08-06',
         'available': []
     },
     {
         'date': '2021-08-07',
         'available': []
     },
     {
         'date': '2021-08-08',
         'available': []
     },
     {
         'date': '2021-08-09',
         'available': [
            {'from_hour': '12:30', 'to_hour': '12:15'},
            {'from_hour': '12:30', 'to_hour': '12:15'},
            {'from_hour': '12:30', 'to_hour': '12:15'}
         ]
     },
     # to be continued for a month by month
]

如果你有任何其他的方法，我会欢迎，请在这里分享你的观点

给你我试过的，真的很愚蠢，不起作用

real_available_date_slot = []
for obj in BookingSession.objects.filter(mentor_id='A mentor ID'):
    weekday =  obj.date.isoweekday()
    real_available = []

    available_hour = AvailableHour.objects.filter(weekday__weekday=weekday, weekday__mentor=obj.mentor)
    availables = available_hour.exclude(
        from_hour__gt=obj.to_hour
    ).exclude(
        to_hour__lt=obj.to_hour
    )
    
    for available in availables:
        real_available.append(
            {'from_hour': available.from_hour, 'to_hour': available.to_hour}
        )

    real_available_date_slot.append({
        obj.date: real_available
    })

我也尝试过其他不同的方法，但我没有任何解决办法

有人能分享你的想法吗？我们如何解决我的问题？你对这类事情的质疑方式是什么？还是我为这个案子做了不恰当的数据库设计

Answer 1

例如，您可以将可用性保存为15分钟的时段。 在student和mentor之间没有BookingSession链接，您可以在student（用户）和AvailableHour对象之间有它的链接

 class BookingSession(models.Model):
   student = models.ForeignKey(
        User,
        on_delete=models.CASCADE,
        related_name="student_booking"
    )

在AvailableHour模型中，可以有一个ForeignKey字段链接到与其相关的Bookingsession对象

# this is a timeslot now
class AvailableHour(models.Model): #Based on weekday
    weekday = models.ForeignKey(
        WeekDay,
        on_delete=models.CASCADE,
        related_name="available_hour"
    )
    from_hour = models.TimeField()
    to_hour = models.TimeField()
    booked_by = ForeignKey(User, null=True)

当过滤显示时，您只需过滤掉不包含booked_by==null的任何时隙

AvailableHour.objects.filter(weekday__weekday=weekday, weekday__mentor=obj.mentor, booked_by=null)