feat: event with ongoing occurrences can have space for enrolment

An event with ongoing occurrences can have space for enrolment if
the enrolement hasn't been set to end before an occurence starts.

Refs: PT-1952

Author: charn

occurrences/models.py

@@ -291,35 +291,48 @@ def has_enrolments_system(self) -> bool:
 
     def has_space_for_enrolments(self) -> Optional[bool]:
         """
-        Determines whether any (upcoming) occurrence has any space left
+        Determines whether any upcoming or ongoing occurrence has any space left
         for enrolments.
 
         Returns:
-            - True: If at least one upcoming occurrence has space for enrolments.
+            - True: If at least one upcoming or ongoing occurrence has space for
+                enrolments.
             - False: If no upcoming occurrences have space for enrolments.
             - None: If the event doesn't utilize the enrolments system or
                 relies on an external enrolments system.
         """
         if not self.has_enrolments_system() or self.has_external_enrolments_system():
             return None
 
-        return any(
+        has_upcoming_space = any(
             occurrence.has_space_left()
             for occurrence in self.occurrences.filter_upcoming()
         )
 
+        if self.enrolment_end_days is None:
+            # No limit to when enrolments can be made before the occurrence start.
+            return has_upcoming_space or any(
+                occurrence.has_space_left()
+                for occurrence in self.occurrences.filter_ongoing()
+            )
+
+        return has_upcoming_space
+
 
 class OccurrenceQueryset(models.QuerySet):
     def delete(self, *args, **kwargs):
         for obj in self:
             obj.delete()
 
     def filter_upcoming(self, *args, **kwargs):
-        """Filter occurrences that are not not cancelled and
-        are held in the future.
-        """
+        """Filter occurrences that are not cancelled and are held in the future."""
         return self.filter(cancelled=False, start_time__gte=timezone.now())
 
+    def filter_ongoing(self, *args, **kwargs):
+        """Filter occurrences that are not cancelled and are ongoing at the moment."""
+        now = timezone.now()
+        return self.filter(cancelled=False, start_time__lte=now, end_time__gte=now)
+
 
 class Occurrence(GDPRModel, SerializableMixin, TimestampedModel):
     OCCURRENCE_SEAT_TYPE_CHILDREN_COUNT = "children_count"

occurrences/schema.py

@@ -219,7 +219,8 @@ def resolve_last_occurrence_datetime(self, info, **kwargs):
 
     def resolve_has_space_for_enrolments(self, info, **kwargs):
         """
-        Determines whether any upcoming occurrence has any space left for enrolments.
+        Determines whether any upcoming or ongoing occurrence has any space left for
+        enrolments.
 
         This method leverages the internal `has_space_for_enrolments` logic to ascertain
         if there are any future event occurrences with available spaces for enrollment.
@@ -231,7 +232,8 @@ def resolve_has_space_for_enrolments(self, info, **kwargs):
                 (may not be used in this specific implementation).
 
         Returns:
-            - True: If at least one upcoming occurrence has space for enrolments.
+            - True: If at least one upcoming or ongoing occurrence has space for
+                enrolments.
             - False: If no upcoming occurrences have space for enrolments.
             - None: If the event doesn't utilize the enrolments system or
                 relies on an external enrolments system.

occurrences/tests/test_models.py

@@ -980,20 +980,90 @@ def test_palvelutarjotin_event_has_space_for_enrolments_returning_boolean(
     mock_get_event_data,
 ):
     p_event = PalvelutarjotinEventFactory()
+    # Past occurrences
+    OccurrenceFactory.create_batch(
+        4,
+        p_event=p_event,
+        cancelled=False,
+        start_time=timezone.now() - timedelta(days=2),
+        end_time=timezone.now() - timedelta(days=1),
+    )
+    # Ongoing occurrences
+    OccurrenceFactory.create_batch(
+        2,
+        p_event=p_event,
+        cancelled=False,
+        start_time=timezone.now() - timedelta(days=1),
+        end_time=timezone.now() + timedelta(days=1),
+    )
+    # Future occurrences
     OccurrenceFactory.create_batch(
         3,
         p_event=p_event,
         cancelled=False,
         start_time=timezone.now() + timedelta(days=1),
+        end_time=timezone.now() + timedelta(days=2),
+    )
+    assert p_event.occurrences.count() == 9
+    assert p_event.occurrences.filter_upcoming().count() == 3
+    assert p_event.occurrences.filter_ongoing().count() == 2
+    with patch(
+        "occurrences.models.PalvelutarjotinEvent.has_external_enrolments_system",
+        return_value=False,
+    ):
+        with patch(
+            "occurrences.models.PalvelutarjotinEvent.has_internal_enrolments_system",
+            return_value=True,
+        ):
+            with patch(
+                "occurrences.models.Occurrence.has_space_left"
+            ) as mock_has_space_left:
+                mock_has_space_left.return_value = False
+                assert p_event.has_space_for_enrolments() is False
+                assert mock_has_space_left.call_count == 3
+    with patch(
+        "occurrences.models.PalvelutarjotinEvent.has_external_enrolments_system",
+        return_value=False,
+    ):
+        with patch(
+            "occurrences.models.PalvelutarjotinEvent.has_internal_enrolments_system",
+            return_value=True,
+        ):
+            with patch(
+                "occurrences.models.Occurrence.has_space_left"
+            ) as mock_has_space_left:
+                # 2nd occurrence returns True, so result is True
+                # and any-call returns after 2nd round.
+                mock_has_space_left.side_effect = [False, True, False]
+                assert p_event.has_space_for_enrolments() is True
+                assert mock_has_space_left.call_count == 2
+
+
+@pytest.mark.django_db
+def test_palvelutarjotin_event_has_space_for_enrolments_ongoing_events(
+    mock_get_event_data,
+):
+    """Ongoing events are not considered"""
+    p_event = PalvelutarjotinEventFactory(enrolment_end_days=None)
+    # Past occurrences
+    OccurrenceFactory.create_batch(
+        2,
+        p_event=p_event,
+        cancelled=False,
+        start_time=timezone.now() - timedelta(days=2),
+        end_time=timezone.now() - timedelta(days=1),
     )
+    # Ongoing occurrences
     OccurrenceFactory.create_batch(
         3,
         p_event=p_event,
         cancelled=False,
         start_time=timezone.now() - timedelta(days=1),
+        end_time=timezone.now() + timedelta(days=1),
     )
-    assert p_event.occurrences.count() == 6
-    assert p_event.occurrences.filter_upcoming().count() == 3
+    assert p_event.occurrences.count() == 5
+    assert p_event.occurrences.filter_upcoming().count() == 0
+    assert p_event.occurrences.filter_ongoing().count() == 3
     with patch(
         "occurrences.models.PalvelutarjotinEvent.has_external_enrolments_system",
         return_value=False,