AKModel/models.py

@@ -423,6 +423,9 @@ class AKSlot(models.Model):
         """
         return (timezone.now() - self.updated).total_seconds()
 
+    def overlaps(self, other: "AKSlot"):
+        return self.start <= other.end  <= self.end or self.start <= other.start <= self.end
+
 
 class AKOrgaMessage(models.Model):
     ak = models.ForeignKey(to=AK, on_delete=models.CASCADE, verbose_name=_('AK'),
@@ -515,5 +518,64 @@ class ConstraintViolation(models.Model):
 
     get_details.short_description = _('Details')
 
+    aks_tmp = set()
+    @property
+    def _aks(self):
+        """
+        Get all AKs belonging to this constraint violation
+
+        The distinction between real and tmp relationships is needed since many to many
+        relations only work for objects already persisted in the database
+
+        :return: set of all AKs belonging to this constraint violation
+        :rtype: set(AK)
+        """
+        if self.pk and self.pk > 0:
+            return set(self.aks.all())
+        return self.aks_tmp
+
+    # TODO Automatically save this
+    ak_slots_tmp = set()
+    @property
+    def _ak_slots(self):
+        """
+        Get all AK Slots belonging to this constraint violation
+
+        The distinction between real and tmp relationships is needed since many to many
+        relations only work for objects already persisted in the database
+
+        :return: set of all AK Slots belonging to this constraint violation
+        :rtype: set(AKSlot)
+        """
+        if self.pk and self.pk > 0:
+            return set(self.ak_slots.all())
+        return self.ak_slots_tmp
+
+    def save(self, *args, **kwargs):
+        super().save(*args, **kwargs)
+        # Store temporary m2m-relations in db
+        for ak in self.aks_tmp:
+            self.aks.add(ak)
+        for ak_slot in self.ak_slots_tmp:
+            self.ak_slots.add(ak_slot)
+
     def __str__(self):
         return f"{self.get_level_display()}: {self.get_type_display()} [{self.get_details()}]"
+
+    def match(self, other):
+        if not isinstance(other, ConstraintViolation):
+            return False
+        if self.type != other.type:
+            return False
+        for field_mm in self.FIELDS_MM:
+            s: set = getattr(self, field_mm)
+            o: set = getattr(other, field_mm)
+            if len(s) != len(o):
+                return False
+            if len(s.intersection(o)) != len(s):
+                return False
+        for field in self.FIELDS:
+            if getattr(self, field) != getattr(other, field):
+                return False
+        return True
+

AKScheduling/models.py

-# Create your models here.
+from django.db.models.signals import post_save
+from django.dispatch import receiver
+
+from AKModel.availability.models import Availability
+from AKModel.models import AK, AKSlot, Room, Event, AKOwner, ConstraintViolation
+
+
+@receiver(post_save, sender=AK)
+def ak_changed_handler(sender, instance: AK, **kwargs):
+    # Changes might affect: Owner(s), Requirements, Conflicts, Prerequisites, Category, Interest
+    print(f"{instance} changed")
+
+    event = instance.event
+
+    # Owner might have changed: Might affect multiple AKs by the same owner at the same time
+    conflicts = []
+    violation_type = ConstraintViolation.ViolationType.OWNER_TWO_SLOTS
+    # For all owners...
+    for owner in instance.owners.all():
+        # ...find overlapping AKs...
+        slots_by_owner : [AKSlot] = []
+        slots_by_owner_this_ak : [AKSlot] = []
+        aks_by_owner = owner.ak_set.all()
+        for ak in aks_by_owner:
+            if ak != instance:
+                slots_by_owner.extend(ak.akslot_set.filter(start__isnull=False))
+            else:
+                # ToDo Fill this outside of loop?
+                slots_by_owner_this_ak.extend(ak.akslot_set.filter(start__isnull=False))
+        for slot in slots_by_owner_this_ak:
+            for other_slot in slots_by_owner:
+                if slot.overlaps(other_slot):
+                    c = ConstraintViolation(
+                        type=violation_type,
+                        level=ConstraintViolation.ViolationLevel.VIOLATION,
+                        event=event,
+                        ak_owner=owner
+                    )
+                    c.aks_tmp.add(instance)
+                    c.aks_tmp.add(other_slot.ak)
+                    c.ak_slots_tmp.add(slot)
+                    c.ak_slots_tmp.add(other_slot)
+                    conflicts.append(c)
+        print(f"{owner} has the following conflicts: {conflicts}")
+    # ... and compare to/update list of existing violations of this type:
+    current_violations = list(instance.constraintviolation_set.filter(type=violation_type))
+    print(current_violations)
+    for conflict in conflicts:
+        # eq_violation_index = -1
+        try:
+            current_violations.remove(conflict)
+            print(f"Found existing conflict {conflict}")
+        except ValueError:
+            conflict.save()
+        """for i, other_violation in enumerate(current_violations):
+            if conflict == other_violation:
+                eq_violation_index = i
+                break
+        if eq_violation_index > -1:"""
+        # TODO Remove from list of current_violations if an equal new one is found
+        # TODO Otherwise, store this conflict in db
+        # conflict.save()
+    # TODO Remove all violations still in current_violations
+    for old_violation in current_violations:
+        old_violation.delete()
+
+
+@receiver(post_save, sender=AKSlot)
+def akslot_changed_handler(sender, instance, **kwargs):
+    # Changes might affect: Duplicate parallel, Two in room
+    print(f"{sender} changed")
+    # TODO Replace with real handling
+
+
+@receiver(post_save, sender=Room)
+def room_changed_handler(sender, **kwargs):
+    # Changes might affect: Room size, Requirement
+    print(f"{sender} changed")
+    # TODO Replace with real handling
+
+
+@receiver(post_save, sender=Availability)
+def availability_changed_handler(sender, **kwargs):
+    # Changes might affect: category availability, AK availability, Room availability
+    print(f"{sender} changed")
+    # TODO Replace with real handling
+
+
+@receiver(post_save, sender=Event)
+def room_changed_handler(sender, **kwargs):
+    # Changes might affect: Reso-Deadline
+    print(f"{sender} changed")
+    # TODO Replace with real handling