Add option to match course groups via parent groups and preset subject

The match of subjects is done case-insensitive and by the short name.
In order to set the subject the group form from the core is extended by this app.

Also add config option to use class groups instead of building course groups.

aleksis/apps/untis/forms.py

+from constance import config
 from django import forms
 from django.utils.translation import ugettext_lazy as _
+from material import Fieldset
+
+from aleksis.core.forms import EditGroupForm
 
 
 class UntisUploadForm(forms.Form):
     untis_xml = forms.FileField(label=_("Untis XML export"))
+
+
+if config.UNTIS_IMPORT_MYSQL_USE_COURSE_GROUPS:
+    EditGroupForm.add_node_to_layout(Fieldset(_("UNTIS import"), "untis_subject"))

aleksis/apps/untis/model_extensions.py

-from jsonstore import IntegerField
+from constance import config
+from django.utils.translation import gettext as _
+from jsonstore import IntegerField, CharField
 
 from aleksis.apps.chronos import models as chronos_models
 from aleksis.core import models as core_models
@@ -6,6 +8,17 @@ from aleksis.core import models as core_models
 # Core models
 core_models.Person.field(import_ref_untis=IntegerField())
 core_models.Group.field(import_ref_untis=IntegerField())
+if config.UNTIS_IMPORT_MYSQL_USE_COURSE_GROUPS:
+    core_models.Group.field(
+        untis_subject=CharField(
+            verbose_name=_("UNTIS subject"),
+            help_text=_(
+                "The UNTIS import will use this for matching course groups (along with parent groups)."
+            ),
+            blank=True, null=True,
+            max_length=255
+        )
+    )
 
 # Chronos models
 chronos_models.Subject.field(import_ref_untis=IntegerField())

aleksis/apps/untis/settings.py

@@ -56,6 +56,10 @@ CONSTANCE_CONFIG = {
     "UNTIS_IMPORT_MYSQL_UPDATE_SUPERVISION_AREAS": (
         True,
         _("Update values of existing supervision areas?")
+    ),
+    "UNTIS_IMPORT_MYSQL_USE_COURSE_GROUPS": (
+        True,
+        _("Build or search course groups for every course instead of setting classes as groups.")
     )
 }
 
@@ -76,5 +80,6 @@ CONSTANCE_CONFIG_FIELDSETS = {
         "UNTIS_IMPORT_MYSQL_UPDATE_GROUPS_OVERWRITE_OWNERS",
         "UNTIS_IMPORT_MYSQL_UPDATE_ROOMS_NAME",
         "UNTIS_IMPORT_MYSQL_UPDATE_SUPERVISION_AREAS",
+        "UNTIS_IMPORT_MYSQL_USE_COURSE_GROUPS",
     ),
 }

aleksis/apps/untis/util/mysql/importers/lessons.py

 import logging
+from typing import Union, List
 
+from constance import config
+from django.db.models import Model, QuerySet
 from django.utils.translation import gettext as _
 
 from aleksis.apps.chronos import models as chronos_models
@@ -23,6 +26,14 @@ def sync_m2m(new_items, m2m_qs):
             logger.info("  Many-to-many sync: item removed")
 
 
+def compare_m2m(
+    a: Union[List[Model], QuerySet], b: Union[List[Model], QuerySet]
+) -> bool:
+    ids_a = sorted([i.id for i in a])
+    ids_b = sorted([i.id for i in b])
+    return ids_a == ids_b
+
+
 def import_lessons(
     time_periods_ref, rooms_ref, subjects_ref, teachers_ref, classes_ref
 ):
@@ -107,26 +118,73 @@ def import_lessons(
                 c = classes_ref[class_id]
                 course_classes.append(c)
 
-            # Build names and refs for course groups
-            group_short_name = "{}-{}".format(
-                "".join([c.short_name for c in course_classes]), subject.abbrev
-            )
-            group_name = "{}: {}".format(
-                ", ".join([c.short_name for c in course_classes]), subject.abbrev
-            )
-            group_import_ref = -int("{}{}".format(lesson_id, i))
+            if config.UNTIS_IMPORT_MYSQL_USE_COURSE_GROUPS:
+                group_import_ref = -int("{}{}".format(lesson_id, i))
+                subject_ref = subject.abbrev
 
-            # Get or create course group
-            course_group, created = core_models.Group.objects.get_or_create(
-                short_name=group_short_name, defaults={"name": group_name}
-            )
-            course_group.import_ref_untis = group_import_ref
-            course_group.name = group_name
-            course_group.save()
-            course_group.parent_groups.set(course_classes)
+                # Search by parent groups and subject
+                qs = core_models.Group.objects.filter(
+                    parent_groups__in=[c.id for c in course_classes],
+                    untis_subject__iexact=subject_ref,
+                )
 
-            if created:
-                logger.info("    Course group created")
+                # Check if found groups match
+                match = False
+                if qs.exists():
+                    if compare_m2m(course_classes, qs[0].parent_groups.all()):
+                        match = True
+                        course_group = qs[0]
+                        logger.info(
+                            "    Course group found by searching by parent groups and subject"
+                        )
+
+                changed = False
+                if not match:
+                    # No matching group found
+
+                    # Build names and refs for course groups
+                    group_short_name = "{}-{}".format(
+                        "".join([c.short_name for c in course_classes]), subject.abbrev
+                    )
+                    group_name = "{}: {}".format(
+                        ", ".join([c.short_name for c in course_classes]),
+                        subject.abbrev,
+                    )
+
+                    # Get or create course group
+                    course_group, created = core_models.Group.objects.get_or_create(
+                        short_name=group_short_name, defaults={"name": group_name}
+                    )
+
+                    # Log
+                    if created:
+                        logger.info("    Course group created")
+
+                    # Update parent groups
+                    sync_m2m(course_classes, course_group.parent_groups)
+
+                    # Update name
+                    if course_group.name != group_name:
+                        course_group.name = group_name
+                        logger.info("    Name of course group updated")
+
+                        changed = True
+
+                # Update import ref
+                if (
+                    course_group.import_ref_untis != group_import_ref
+                ):  # or course_group.untis_subject != subject_ref:
+                    course_group.import_ref_untis = group_import_ref
+                    # course_group.subject_ref = subject_ref
+                    logger.info("    Import reference of course group updated")
+                    changed = True
+
+                if changed:
+                    course_group.save()
+
+                groups = [course_group]
+            else:
+                groups = course_classes
 
             # Create new lesson
             date_start = untis_date_to_date(term.datefrom)
@@ -168,7 +226,6 @@ def import_lessons(
                 logger.info("    New lesson created")
 
             # Sync groups
-            groups = [course_group]
             sync_m2m(groups, lesson.groups)
 
             # Sync teachers