fix: update person retention period deletion logic

Update person retention period deletion logic
to return persons who:
1. Don't have a user account
2. Don't have any valid enrolments
3. Don't have any valid event queue enrolments

Add tests.

Refs: PT-1946

Author: mhieta

organisations/models.py

@@ -8,7 +8,7 @@
 from django.contrib.auth.models import UserManager
 from django.contrib.postgres.fields import ArrayField
 from django.db import models, router, transaction
-from django.db.models import Max, Q
+from django.db.models import Q
 from django.db.models.deletion import Collector
 from django.utils import timezone
 from django.utils.translation import gettext_lazy as _
@@ -37,29 +37,51 @@ def user_can_view(self, user):
             return self.none()
 
     def retention_period_exceeded(self):
+        """
+        Return queryset of Person objects whose personal data
+        retention period has exceeded.
+
+        This excludes:
+        - Persons with a user account
+        - Persons with any valid (recent) enrolments
+        """
         earliest_valid_timestamp = timezone.now() - relativedelta(
             months=settings.PERSONAL_DATA_RETENTION_PERIOD_MONTHS
         )
 
-        all_enrolments_too_old = Q(max_enrolment_end_time=None) | Q(
-            max_enrolment_end_time__lt=earliest_valid_timestamp
-        )
-        all_study_groups_too_old = Q(max_studygroup_end_time=None) | Q(
-            max_studygroup_end_time__lt=earliest_valid_timestamp
-        )
-
-        return (
-            # At least for now returns only unauthenticated Person's
-            self.filter(user=None)
-            .annotate(
-                max_enrolment_end_time=Max("enrolment__occurrence__end_time"),
-                max_studygroup_end_time=Max(
-                    "studygroup__enrolments__occurrence__end_time"
-                ),
+        # Find persons with any valid enrolments or
+        # event queue enrolments (as person or study group contact)
+        valid_enrolment_persons = self.filter(
+            Q(enrolment__occurrence__end_time__gt=earliest_valid_timestamp)
+            | Q(
+                studygroup__enrolments__occurrence__end_time__gt=earliest_valid_timestamp
+            )
+            | Q(
+                eventqueueenrolment__p_event__occurrences__end_time__gt=earliest_valid_timestamp
+            )
+        ).distinct()
+
+        # Return persons who:
+        # 1. Don't have a user account
+        # 2. Don't have any valid enrolments (either as person or study group contact)
+        # 3. Don't have any valid event queue enrolments
+        old_enrolment_filter = (
+            Q(enrolment__occurrence__end_time__lte=earliest_valid_timestamp)
+            | Q(enrolment__occurrence__end_time__isnull=True)
+            | Q(
+                studygroup__enrolments__occurrence__end_time__lte=earliest_valid_timestamp
             )
-            .filter(all_enrolments_too_old & all_study_groups_too_old)
+            | Q(studygroup__enrolments__occurrence__end_time__isnull=True)
+            | Q(
+                eventqueueenrolment__p_event__occurrences__end_time__lte=earliest_valid_timestamp
+            )
+            | Q(eventqueueenrolment__p_event__occurrences__end_time__isnull=True)
         )
 
+        persons = self.filter(user__isnull=True).filter(old_enrolment_filter)
+        persons = persons.exclude(id__in=valid_enrolment_persons.values("id"))
+        return persons.distinct()
+
     @transaction.atomic
     def delete(self):
         for obj in self:

organisations/tests/test_models.py

@@ -4,7 +4,12 @@
 from django.db import IntegrityError
 from django.utils import timezone
 
-from occurrences.factories import EnrolmentFactory, PalvelutarjotinEventFactory
+from occurrences.factories import (
+    EnrolmentFactory,
+    EventQueueEnrolmentFactory,
+    OccurrenceFactory,
+    PalvelutarjotinEventFactory,
+)
 from organisations.factories import (
     OrganisationFactory,
     OrganisationProposalFactory,
@@ -210,6 +215,75 @@ def test_too_old_personal_data(mock_get_event_data):
     assert all(person in results for person in expected_people)
 
 
+@pytest.mark.django_db
+def test_old_personal_data_deletion_with_valid_enrolments(mock_get_event_data):
+    too_old = timezone.now() - relativedelta(months=24, days=1)
+    still_valid = timezone.now() - relativedelta(days=1)
+
+    (
+        enrolment_person,
+        study_group_person,
+        enrolment_and_study_group_person,
+        no_enrolment_or_study_group_person,
+        event_queue_enrolment_person,
+        event_queue_study_group_person,
+    ) = PersonFactory.create_batch(6, user=None)
+
+    # person with a too old enrolment
+    EnrolmentFactory(person=enrolment_person, occurrence__end_time=too_old)
+
+    # person with a too old study group
+    EnrolmentFactory(
+        study_group__person=study_group_person, occurrence__end_time=too_old
+    )
+
+    # person with too old enrolment and study group
+    EnrolmentFactory(
+        person=enrolment_and_study_group_person,
+        study_group__person=enrolment_and_study_group_person,
+        occurrence__end_time=too_old,
+    )
+
+    too_old_p_event = PalvelutarjotinEventFactory()
+    OccurrenceFactory(end_time=too_old, p_event=too_old_p_event)
+
+    EventQueueEnrolmentFactory(
+        person=event_queue_enrolment_person, p_event=too_old_p_event
+    )
+    EventQueueEnrolmentFactory(
+        study_group__person=event_queue_study_group_person,
+        p_event=too_old_p_event,
+    )
+
+    valid_p_event = PalvelutarjotinEventFactory()
+    OccurrenceFactory(end_time=still_valid, p_event=valid_p_event)
+    # valid event queue enrolment for the event queue enrolment person
+    EventQueueEnrolmentFactory(
+        person=event_queue_enrolment_person, p_event=valid_p_event
+    )
+
+    # valid enrolment for the enrolment person
+    EnrolmentFactory(person=enrolment_person, occurrence__end_time=still_valid)
+    # valid enrolment for the study group person
+    EnrolmentFactory(
+        study_group__person=study_group_person, occurrence__end_time=still_valid
+    )
+    # valid enrolment for the event queue enrolment person
+    EventQueueEnrolmentFactory(
+        person=event_queue_enrolment_person, p_event=too_old_p_event
+    )
+    # valid enrolment for the event queue study group person
+    EventQueueEnrolmentFactory(
+        study_group__person=event_queue_study_group_person, p_event=too_old_p_event
+    )
+    # person with a user
+    PersonFactory(user=UserFactory())
+
+    # only the person without any enrolments should be in the results
+    results = Person.objects.retention_period_exceeded()
+    assert len(results) == 3
+
+
 @pytest.mark.django_db
 @pytest.mark.parametrize("delete_via_queryset", (False, True))
 def test_user_deletion_deletes_palvelutarjotin_event_contact_info(delete_via_queryset):