Factor timeslot computation into Event model

AKModel/models.py

@@ -116,6 +116,52 @@ class Event(models.Model):
     def get_aks_without_availabilities(self):
         return self.ak_set.annotate(Count('availabilities', distinct=True)).annotate(Count('owners', distinct=True)).filter(availabilities__count=0, owners__count__gt=0)
 
+    def time_slots(self, *, slots_in_an_hour=1.0):
+        from AKModel.availability.models import Availability
+
+        rooms = Room.objects.filter(event=self)
+        slot_duration = timedelta(hours=(1.0 / slots_in_an_hour))
+        slot_index = 0
+        current_slot = self.start
+        current_block = []
+        previous_slot = None
+
+        room_availabilities = list({availability
+                               for room in rooms
+                               for availability in room.availabilities.all()})
+
+        while current_slot < self.end:
+            slot = Availability(event=self,
+                                start=current_slot,
+                                end=current_slot + slot_duration)
+
+            if any((availability.contains(slot)
+                    for availability in room_availabilities)):
+                if previous_slot is not None and previous_slot + slot_duration < current_slot:
+                    yield current_block
+                    current_block = []
+
+                current_block.append(slot_index)
+                previous_slot = current_slot
+
+            slot_index += 1
+            current_slot += slot_duration
+
+        yield current_block
+
+    def time_slot(self, *, time_slot_index, slots_in_an_hour=1.0):
+        from AKModel.availability.models import Availability
+
+        slot_duration = timedelta(hours=(1.0 / slots_in_an_hour))
+
+        start = self.start + time_slot_index * slot_duration
+
+        return Availability(event=self,
+                            start=start,
+                            end=start + slot_duration)
+
+
+
 
 class AKOwner(models.Model):
     """ An AKOwner describes the person organizing/holding an AK.

AKModel/views.py

@@ -229,11 +229,6 @@ class AKJSONExportView(AdminViewMixin, FilterByEventSlugMixin, ListView):
         for slot in context["slots"]:
             slot.slots_in_an_hour = SLOTS_IN_AN_HOUR
 
-        slot_duration = timedelta(hours=(1.0 / SLOTS_IN_AN_HOUR))
-        slot_index = 1
-        current_slot = self.event.start
-        current_block = []
-        previous_slot = None
         ak_availabilities = {slot.ak.pk: availability
                              for slot in context["slots"]
                              for availability in slot.ak.availabilities.all()}
@@ -244,20 +239,17 @@ class AKJSONExportView(AdminViewMixin, FilterByEventSlugMixin, ListView):
                                       for person in AKOwner.objects.filter(event=self.event)
                                       for availability in person.availabilities.all()}
 
-        while current_slot < self.event.end:
-            slot = Availability(event=self.event,
-                                start=current_slot,
-                                end=current_slot + slot_duration)
 
-            # also check track availability?
-            constraints = []
 
-            for (room, availability) in room_availabilities.items():
-                if availability.contains(slot):
-                    constraints.append(f"availability-room-{room}")
+        for block in self.event.time_slots(slots_in_an_hour=SLOTS_IN_AN_HOUR):
+            current_block = []
+
+            for slot_index in block:
+                slot = self.event.time_slot(time_slot_index=slot_index,
+                                            slots_in_an_hour=SLOTS_IN_AN_HOUR)
+                constraints = []
 
-            if constraints:
-                if current_slot < self.event.reso_deadline:
+                if slot.end < self.event.reso_deadline:
                     constraints.append("resolution")
 
                 for (ak, availability) in ak_availabilities.items():
@@ -268,9 +260,9 @@ class AKJSONExportView(AdminViewMixin, FilterByEventSlugMixin, ListView):
                     if availability.contains(slot):
                         constraints.append(f"availability-person-{person}")
 
-                if previous_slot is not None and previous_slot + slot_duration < current_slot:
-                    timeslots["blocks"].append(current_block)
-                    current_block = []
+                for (room, availability) in room_availabilities.items():
+                    if availability.contains(slot):
+                        constraints.append(f"availability-room-{room}")
 
                 current_block.append({
                     "id": slot_index,
@@ -280,12 +272,6 @@ class AKJSONExportView(AdminViewMixin, FilterByEventSlugMixin, ListView):
                     "fulfilled_time_constraints": constraints,
                     })
 
-                previous_slot = current_slot
-
-            slot_index += 1
-            current_slot += slot_duration
-
-        if current_block != []:
             timeslots["blocks"].append(current_block)
 
         context["timeslots"] = json.dumps(timeslots)