✨ GDPR: efficient create_log method

2 files changed, 72 insertions, 3 deletions

diff --git a/ishtar_common/models.py b/ishtar_common/models.py
index 35c59a94e..8cb59be3e 100644
--- a/ishtar_common/models.py
+++ b/ishtar_common/models.py
@@ -3218,7 +3218,7 @@ GDPR_ACTIVITY_DICT = dict(GDPR_ACTIVITY)
 
 class GDPRPerson(models.Model):
     person = models.ForeignKey(Person, verbose_name=_("Person"), on_delete=models.SET_NULL,
-                               blank=True, null=True)
+                               blank=True, null=True, related_name="gdpr_person")
     raw_name = models.CharField(_("Raw name"), max_length=300, default="-")
 
     class Meta:
@@ -3245,8 +3245,8 @@ class GDPRLog(models.Model):
     @property
     def activity_lbl(self):
         if self.activity not in GDPR_ACTIVITY_DICT:
-            return str(_("Unknown activity :")) + self.activity
-        return GDPR_ACTIVITY_DICT[self.activity]
+            return str(_("Unknown activity :")) + str(self.activity)
+        return GDPR_ACTIVITY_DICT[str(self.activity)]
 
     @property
     def persons_lbl(self):
@@ -3259,6 +3259,27 @@ class GDPRLog(models.Model):
     def __str__(self):
         return f"{self.user.username} - {self.date} - {self.activity_lbl}"
 
+    @classmethod
+    def create_log(cls, user_id, ip, activity, person_query):
+        log = cls.objects.create(user_id=user_id, ip=ip, activity=activity)
+        person_query = person_query.exclude(raw_name__isnull=True).exclude(raw_name="")
+
+        # create all missing GDPRPerson
+        missing_gdpr_person_q = person_query.filter(gdpr_person=None)
+        gdpr_persons_creation = []
+        values = missing_gdpr_person_q.values_list("id", "raw_name")
+        for person_id, raw_name in values:
+            gdpr_persons_creation.append(GDPRPerson(person_id=person_id, raw_name=raw_name))
+        GDPRPerson.objects.bulk_create(gdpr_persons_creation)
+
+        # attach gdpr persons
+        gdpr_persons = []
+        values = person_query.values_list("gdpr_person__pk", flat=True)
+        for pk in values:
+            gdpr_persons.append(cls.persons.through(gdprperson_id=pk, gdprlog_id=log.pk))
+        cls.persons.through.objects.bulk_create(gdpr_persons)
+
+
 class ProfileType(GeneralType):
     groups = models.ManyToManyField(Group, verbose_name=_("Groups"), blank=True)
 
diff --git a/ishtar_common/tests.py b/ishtar_common/tests.py
index f14872295..e8821f18c 100644
--- a/ishtar_common/tests.py
+++ b/ishtar_common/tests.py
@@ -2060,6 +2060,54 @@ class MergeTest(TestCase):
         self.assertEqual(self.person_1.merge_candidate.count(), init_mc)
 
 
+class GDPRTest(TestCase):
+    def setUp(self):
+        self.user, created = User.objects.get_or_create(username="username")
+        self.person_1 = models.Person.objects.create(
+            name="Boule",
+            surname=" ",
+            history_modifier=self.user,
+        )
+        self.person_2 = models.Person.objects.create(
+            name="Bill",
+            history_modifier=self.user,
+            surname="Peyo",
+        )
+        self.person_3 = models.Person.objects.create(
+            name="George", history_modifier=self.user,
+        )
+
+    def test_create_log(self):
+        nb = models.GDPRLog.objects.count()
+        nb_person = models.GDPRPerson.objects.count()
+
+        q = models.Person.objects.filter(pk__in=(self.person_1.pk, self.person_2.pk))
+        models.GDPRLog.create_log(self.user.pk, "127.0.0.1", "DC", q)
+        self.assertEqual(models.GDPRLog.objects.count(), nb + 1)
+        self.assertEqual(models.GDPRPerson.objects.count(), nb_person + 2)
+        last_log = models.GDPRLog.objects.order_by("-pk").all()[0]
+        self.assertEqual(last_log.persons.count(), 2)
+
+        nb = models.GDPRLog.objects.count()
+        nb_person = models.GDPRPerson.objects.count()
+        q = models.Person.objects.filter(pk__in=(self.person_1.pk, self.person_3.pk))
+        models.GDPRLog.create_log(self.user.pk, "127.0.1.1", "DE", q)
+        self.assertEqual(models.GDPRLog.objects.count(), nb + 1)
+        self.assertEqual(models.GDPRPerson.objects.count(), nb_person + 1)
+        last_log = models.GDPRLog.objects.order_by("-pk").all()[0]
+        self.assertEqual(last_log.persons.count(), 2)
+
+    def test_create_log_performance(self):
+        persons = []
+        for idx in range(5000):
+            persons.append(models.Person(name=f"George {idx + 1}", raw_name=f"George {idx + 1}"))
+        models.Person.objects.bulk_create(persons)
+        n = datetime.datetime.now()
+        q = models.Person.objects
+        models.GDPRLog.create_log(self.user.pk, "127.0.0.1", "DE", q)
+        self.assertTrue((datetime.datetime.now() - n).seconds < 3)
+
+
 class ShortMenuTest(TestCase):
     def setUp(self):
         self.username = "username666"