AKModel/migrations/0068_aktype_slug.py

+# Generated by Django 5.1.6 on 2025-05-11 15:21
+
+from django.db import migrations, models
+
+
+def create_slugs(apps, schema_editor):
+    """
+    Automatically generate slugs from existing type names
+    """
+    AKType = apps.get_model("AKModel", "AKType")
+    for ak_type in AKType.objects.all():
+        slug = ak_type.name.lower().split(" ")[0]
+        ak_type.slug = slug[:30] if len(slug) > 30 else slug
+        ak_type.save()
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('AKModel', '0067_eventparticipant_requirements_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='aktype',
+            name='slug',
+            field=models.SlugField(max_length=30, null=True, verbose_name='Slug'),
+        ),
+        migrations.RunPython(create_slugs, migrations.RunPython.noop),
+        migrations.AlterUniqueTogether(
+            name='aktype',
+            unique_together={('event', 'name')},
+        ),
+        migrations.AlterField(
+            model_name='aktype',
+            name='slug',
+            field=models.SlugField(max_length=30, verbose_name='Slug'),
+        ),
+        migrations.AlterUniqueTogether(
+            name='aktype',
+            unique_together={('event', 'name'), ('event', 'slug')},
+        ),
+    ]

AKModel/migrations/0068_event_export_delete_preferences_participants.py

+# Generated by Django 5.2.1 on 2025-06-17 15:57
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('AKModel', '0067_eventparticipant_requirements_and_more'),
+        ('AKPreference', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='eventparticipant',
+            name='event',
+        ),
+        migrations.RemoveField(
+            model_name='eventparticipant',
+            name='requirements',
+        ),
+        migrations.RemoveField(
+            model_name='availability',
+            name='participant',
+        ),
+        migrations.AddField(
+            model_name='event',
+            name='poll_hidden',
+            field=models.BooleanField(default=True, help_text='Hides preference poll for non-staff users', verbose_name='Poll Hidden'),
+        ),
+        migrations.AddField(
+            model_name='event',
+            name='poll_published_at',
+            field=models.DateTimeField(blank=True, help_text='Timestamp at which the preference poll was published', null=True, verbose_name='Poll published at'),
+        ),
+        migrations.DeleteModel(
+            name='AKPreference',
+        ),
+        migrations.DeleteModel(
+            name='EventParticipant',
+        ),
+        migrations.AddField(
+            model_name='availability',
+            name='participant',
+            field=models.ForeignKey(blank=True, help_text='Participant whose availability this is', null=True,
+                                    on_delete=django.db.models.deletion.CASCADE, related_name='availabilities',
+                                    to='AKPreference.eventparticipant', verbose_name='Participant'),
+        ),
+    ]

AKModel/migrations/0069_merge_20250617_1844.py

+# Generated by Django 5.2.1 on 2025-06-17 18:44
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('AKModel', '0068_aktype_slug'),
+        ('AKModel', '0068_event_export_delete_preferences_participants'),
+    ]
+
+    operations = [
+    ]

AKModel/migrations/0070_requirements_relevant_for_participants.py

+# Generated by Django 5.2.3 on 2025-06-18 10:47
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('AKModel', '0069_merge_20250617_1844'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='akrequirement',
+            name='relevant_for_participants',
+            field=models.BooleanField(default=False, help_text='Show this requirement when collecting participant preferences', verbose_name='Relevant for Participants?'),
+        ),
+    ]

AKModel/serializers.py

 from rest_framework import serializers
 
-from AKModel.models import AK, Room, AKSlot, AKTrack, AKCategory, AKOwner
+from AKModel.models import AK, AKCategory, AKOwner, AKSlot, AKTrack, Room
+
+
+class StringListField(serializers.ListField):
+    """List field containing strings."""
+
+    child = serializers.CharField()
+
+
+class IntListField(serializers.ListField):
+    """List field containing integers."""
+
+    child = serializers.IntegerField()
 
 
 class AKOwnerSerializer(serializers.ModelSerializer):

AKModel/templates/admin/AKModel/export/slides.tex

@@ -19,6 +19,10 @@
 
     \faUser~ {{ translations.who }}
 
+    {% if show_types %}
+        \faList~ {{ translations.types }}
+    {% endif %}
+
     \faClock~ {{ translations.duration }}
 
     \faScroll~{{ translations.reso }}
@@ -45,6 +49,10 @@
 
                 \faUser~ {{ ak.owners_list | latex_escape }}
 
+                {% if show_types %}
+                    \faList~ {{ak.types_list }}
+                {% endif %}
+
                 {% if not result_presentation_mode %}
                     \faClock~ {{ak.durations_list}}
                 {% endif %}

AKModel/tests.py → AKModel/tests/test_views.py

@@ -5,10 +5,21 @@ from django.contrib.auth import get_user_model
 from django.contrib.messages import get_messages
 from django.contrib.messages.storage.base import Message
 from django.test import TestCase
-from django.urls import reverse_lazy, reverse
-
-from AKModel.models import Event, AKOwner, AKCategory, AKTrack, AKRequirement, AK, Room, AKSlot, AKOrgaMessage, \
-    ConstraintViolation, DefaultSlot
+from django.urls import reverse, reverse_lazy
+
+from AKModel.models import (
+    AK,
+    AKCategory,
+    AKOrgaMessage,
+    AKOwner,
+    AKRequirement,
+    AKSlot,
+    AKTrack,
+    ConstraintViolation,
+    DefaultSlot,
+    Event,
+    Room,
+)
 
 
 class BasicViewTests:
@@ -29,9 +40,10 @@ class BasicViewTests:
     since the test framework does not understand the concept of abstract test definitions and would handle this class
     as real test case otherwise, distorting the test results.
     """
+
     # pylint: disable=no-member
     VIEWS = []
-    APP_NAME = ''
+    APP_NAME = ""
     VIEWS_STAFF_ONLY = []
     EDIT_TESTCASES = []
 
@@ -41,16 +53,26 @@ class BasicViewTests:
         """
         user_model = get_user_model()
         self.staff_user = user_model.objects.create(
-            username='Test Staff User', email='teststaff@example.com', password='staffpw',
-            is_staff=True, is_active=True
+            username="Test Staff User",
+            email="teststaff@example.com",
+            password="staffpw",
+            is_staff=True,
+            is_active=True,
         )
         self.admin_user = user_model.objects.create(
-            username='Test Admin User', email='testadmin@example.com', password='adminpw',
-            is_staff=True, is_superuser=True, is_active=True
+            username="Test Admin User",
+            email="testadmin@example.com",
+            password="adminpw",
+            is_staff=True,
+            is_superuser=True,
+            is_active=True,
         )
         self.deactivated_user = user_model.objects.create(
-            username='Test Deactivated User', email='testdeactivated@example.com', password='deactivatedpw',
-            is_staff=True, is_active=False
+            username="Test Deactivated User",
+            email="testdeactivated@example.com",
+            password="deactivatedpw",
+            is_staff=True,
+            is_active=False,
         )
 
     def _name_and_url(self, view_name):
@@ -62,7 +84,9 @@ class BasicViewTests:
         :return: full view name with prefix if applicable, url of the view
         :rtype: str, str
         """
-        view_name_with_prefix = f"{self.APP_NAME}:{view_name[0]}" if self.APP_NAME != "" else view_name[0]
+        view_name_with_prefix = (
+            f"{self.APP_NAME}:{view_name[0]}" if self.APP_NAME != "" else view_name[0]
+        )
         url = reverse(view_name_with_prefix, kwargs=view_name[1])
         return view_name_with_prefix, url
 
@@ -74,7 +98,7 @@ class BasicViewTests:
         :param expected_message: message that should be shown
         :param msg_prefix: prefix for the error message when test fails
         """
-        messages:List[Message] = list(get_messages(response.wsgi_request))
+        messages: List[Message] = list(get_messages(response.wsgi_request))
 
         msg_count = "No message shown to user"
         msg_content = "Wrong message, expected '{expected_message}'"
@@ -95,10 +119,16 @@ class BasicViewTests:
             view_name_with_prefix, url = self._name_and_url(view_name)
             try:
                 response = self.client.get(url)
-                self.assertEqual(response.status_code, 200, msg=f"{view_name_with_prefix} ({url}) broken")
-            except Exception: # pylint: disable=broad-exception-caught
-                self.fail(f"An error occurred during rendering of {view_name_with_prefix} ({url}):"
-                          f"\n\n{traceback.format_exc()}")
+                self.assertEqual(
+                    response.status_code,
+                    200,
+                    msg=f"{view_name_with_prefix} ({url}) broken",
+                )
+            except Exception:  # pylint: disable=broad-exception-caught
+                self.fail(
+                    f"An error occurred during rendering of {view_name_with_prefix} ({url}):"
+                    f"\n\n{traceback.format_exc()}"
+                )
 
     def test_access_control_staff_only(self):
         """
@@ -107,11 +137,16 @@ class BasicViewTests:
         # Not logged in? Views should not be visible
         self.client.logout()
         for view_name_info in self.VIEWS_STAFF_ONLY:
-            expected_response_code = 302 if len(view_name_info) == 2 else view_name_info[2]
+            expected_response_code = (
+                302 if len(view_name_info) == 2 else view_name_info[2]
+            )
             view_name_with_prefix, url = self._name_and_url(view_name_info)
             response = self.client.get(url)
-            self.assertEqual(response.status_code, expected_response_code,
-                             msg=f"{view_name_with_prefix} ({url}) accessible by non-staff")
+            self.assertEqual(
+                response.status_code,
+                expected_response_code,
+                msg=f"{view_name_with_prefix} ({url}) accessible by non-staff",
+            )
 
         # Logged in? Views should be visible
         self.client.force_login(self.staff_user)
@@ -119,20 +154,30 @@ class BasicViewTests:
             view_name_with_prefix, url = self._name_and_url(view_name_info)
             try:
                 response = self.client.get(url)
-                self.assertEqual(response.status_code, 200,
-                                 msg=f"{view_name_with_prefix} ({url}) should be accessible for staff (but isn't)")
+                self.assertEqual(
+                    response.status_code,
+                    200,
+                    msg=f"{view_name_with_prefix} ({url}) should be accessible for staff (but isn't)",
+                )
             except Exception:  # pylint: disable=broad-exception-caught
-                self.fail(f"An error occurred during rendering of {view_name_with_prefix} ({url}):"
-                          f"\n\n{traceback.format_exc()}")
+                self.fail(
+                    f"An error occurred during rendering of {view_name_with_prefix} ({url}):"
+                    f"\n\n{traceback.format_exc()}"
+                )
 
         # Disabled user? Views should not be visible
         self.client.force_login(self.deactivated_user)
         for view_name_info in self.VIEWS_STAFF_ONLY:
-            expected_response_code = 302 if len(view_name_info) == 2 else view_name_info[2]
+            expected_response_code = (
+                302 if len(view_name_info) == 2 else view_name_info[2]
+            )
             view_name_with_prefix, url = self._name_and_url(view_name_info)
             response = self.client.get(url)
-            self.assertEqual(response.status_code, expected_response_code,
-                             msg=f"{view_name_with_prefix} ({url}) still accessible for deactivated user")
+            self.assertEqual(
+                response.status_code,
+                expected_response_code,
+                msg=f"{view_name_with_prefix} ({url}) still accessible for deactivated user",
+            )
 
     def _to_sendable_value(self, val):
         """
@@ -182,16 +227,26 @@ class BasicViewTests:
             self.client.logout()
 
         response = self.client.get(url)
-        self.assertEqual(response.status_code, 200, msg=f"{name}: Could not load edit form via GET ({url})")
+        self.assertEqual(
+            response.status_code,
+            200,
+            msg=f"{name}: Could not load edit form via GET ({url})",
+        )
 
         form = response.context[form_name]
-        data = {k:self._to_sendable_value(v) for k,v in form.initial.items()}
+        data = {k: self._to_sendable_value(v) for k, v in form.initial.items()}
 
         response = self.client.post(url, data=data)
         if expected_code == 200:
-            self.assertEqual(response.status_code, 200, msg=f"{name}: Did not return 200 ({url}")
+            self.assertEqual(
+                response.status_code, 200, msg=f"{name}: Did not return 200 ({url}"
+            )
         elif expected_code == 302:
-            self.assertRedirects(response, target_url, msg_prefix=f"{name}: Did not redirect ({url} -> {target_url}")
+            self.assertRedirects(
+                response,
+                target_url,
+                msg_prefix=f"{name}: Did not redirect ({url} -> {target_url}",
+            )
         if expected_message != "":
             self._assert_message(response, expected_message, msg_prefix=f"{name}")
 
@@ -200,30 +255,42 @@ class ModelViewTests(BasicViewTests, TestCase):
     """
     Basic view test cases for views from AKModel plus some custom tests
     """
-    fixtures = ['model.json']
+
+    fixtures = ["model.json"]
 
     ADMIN_MODELS = [
-        (Event, 'event'), (AKOwner, 'akowner'), (AKCategory, 'akcategory'), (AKTrack, 'aktrack'),
-        (AKRequirement, 'akrequirement'), (AK, 'ak'), (Room, 'room'), (AKSlot, 'akslot'),
-        (AKOrgaMessage, 'akorgamessage'), (ConstraintViolation, 'constraintviolation'),
-        (DefaultSlot, 'defaultslot')
+        (Event, "event"),
+        (AKOwner, "akowner"),
+        (AKCategory, "akcategory"),
+        (AKTrack, "aktrack"),
+        (AKRequirement, "akrequirement"),
+        (AK, "ak"),
+        (Room, "room"),
+        (AKSlot, "akslot"),
+        (AKOrgaMessage, "akorgamessage"),
+        (ConstraintViolation, "constraintviolation"),
+        (DefaultSlot, "defaultslot"),
     ]
 
     VIEWS_STAFF_ONLY = [
-        ('admin:index', {}),
-        ('admin:event_status', {'event_slug': 'kif42'}),
-        ('admin:event_requirement_overview', {'event_slug': 'kif42'}),
-        ('admin:ak_csv_export', {'event_slug': 'kif42'}),
-        ('admin:ak_wiki_export', {'slug': 'kif42'}),
-        ('admin:ak_delete_orga_messages', {'event_slug': 'kif42'}),
-        ('admin:ak_slide_export', {'event_slug': 'kif42'}),
-        ('admin:default-slots-editor', {'event_slug': 'kif42'}),
-        ('admin:room-import', {'event_slug': 'kif42'}),
-        ('admin:new_event_wizard_start', {}),
+        ("admin:index", {}),
+        ("admin:event_status", {"event_slug": "kif42"}),
+        ("admin:event_requirement_overview", {"event_slug": "kif42"}),
+        ("admin:ak_csv_export", {"event_slug": "kif42"}),
+        ("admin:ak_wiki_export", {"slug": "kif42"}),
+        ("admin:ak_delete_orga_messages", {"event_slug": "kif42"}),
+        ("admin:ak_slide_export", {"event_slug": "kif42"}),
+        ("admin:default-slots-editor", {"event_slug": "kif42"}),
+        ("admin:room-import", {"event_slug": "kif42"}),
+        ("admin:new_event_wizard_start", {}),
     ]
 
     EDIT_TESTCASES = [
-        {'view': 'admin:default-slots-editor', 'kwargs': {'event_slug': 'kif42'}, "admin": True},
+        {
+            "view": "admin:default-slots-editor",
+            "kwargs": {"event_slug": "kif42"},
+            "admin": True,
+        },
     ]
 
     def test_admin(self):
@@ -234,24 +301,32 @@ class ModelViewTests(BasicViewTests, TestCase):
         for model in self.ADMIN_MODELS:
             # Special treatment for a subset of views (where we exchanged default functionality, e.g., create views)
             if model[1] == "event":
-                _, url = self._name_and_url(('admin:new_event_wizard_start', {}))
+                _, url = self._name_and_url(("admin:new_event_wizard_start", {}))
             elif model[1] == "room":
-                _, url = self._name_and_url(('admin:room-new', {}))
+                _, url = self._name_and_url(("admin:room-new", {}))
             # Otherwise, just call the creation form view
             else:
-                _, url = self._name_and_url((f'admin:AKModel_{model[1]}_add', {}))
+                _, url = self._name_and_url((f"admin:AKModel_{model[1]}_add", {}))
             response = self.client.get(url)
-            self.assertEqual(response.status_code, 200, msg=f"Add form for model {model[1]} ({url}) broken")
+            self.assertEqual(
+                response.status_code,
+                200,
+                msg=f"Add form for model {model[1]} ({url}) broken",
+            )
 
         for model in self.ADMIN_MODELS:
             # Test the update view using the first existing instance of each model
             m = model[0].objects.first()
             if m is not None:
                 _, url = self._name_and_url(
-                    (f'admin:AKModel_{model[1]}_change', {'object_id': m.pk})
+                    (f"admin:AKModel_{model[1]}_change", {"object_id": m.pk})
                 )
                 response = self.client.get(url)
-                self.assertEqual(response.status_code, 200, msg=f"Edit form for model {model[1]} ({url}) broken")
+                self.assertEqual(
+                    response.status_code,
+                    200,
+                    msg=f"Edit form for model {model[1]} ({url}) broken",
+                )
 
     def test_wiki_export(self):
         """
@@ -260,17 +335,27 @@ class ModelViewTests(BasicViewTests, TestCase):
         """
         self.client.force_login(self.admin_user)
 
-        export_url = reverse_lazy("admin:ak_wiki_export", kwargs={'slug': 'kif42'})
+        export_url = reverse_lazy("admin:ak_wiki_export", kwargs={"slug": "kif42"})
         response = self.client.get(export_url)
         self.assertEqual(response.status_code, 200, "Export not working at all")
 
         export_count = 0
         for _, aks in response.context["categories_with_aks"]:
             for ak in aks:
-                self.assertEqual(ak.include_in_export, True,
-                                 f"AK with export flag set to False (pk={ak.pk}) included in export")
-                self.assertNotEqual(ak.pk, 1, "AK known to be excluded from export (PK 1) included in export")
+                self.assertEqual(
+                    ak.include_in_export,
+                    True,
+                    f"AK with export flag set to False (pk={ak.pk}) included in export",
+                )
+                self.assertNotEqual(
+                    ak.pk,
+                    1,
+                    "AK known to be excluded from export (PK 1) included in export",
+                )
                 export_count += 1
 
-        self.assertEqual(export_count, AK.objects.filter(event_id=2, include_in_export=True).count(),
-                         "Wiki export contained the wrong number of AKs")
+        self.assertEqual(
+            export_count,
+            AK.objects.filter(event_id=2, include_in_export=True).count(),
+            "Wiki export contained the wrong number of AKs",
+        )

AKModel/urls.py

@@ -4,9 +4,10 @@ from django.urls import include, path
 from rest_framework.routers import DefaultRouter
 
 import AKModel.views.api
-from AKModel.views.manage import ExportSlidesView, PlanPublishView, PlanUnpublishView, DefaultSlotEditorView, \
-    AKsByUserView
-from AKModel.views.ak import AKRequirementOverview, AKCSVExportView, AKWikiExportView, AKMessageDeleteView
+from AKModel.views.manage import ExportSlidesView, PlanPublishView, PlanUnpublishView, \
+     PollPublishView, PollUnpublishView, DefaultSlotEditorView, AKsByUserView
+from AKModel.views.ak import AKRequirementOverview, AKCSVExportView, AKWikiExportView, \
+     AKMessageDeleteView
 from AKModel.views.event_wizard import NewEventWizardStartView, NewEventWizardPrepareImportView, \
     NewEventWizardImportView, NewEventWizardActivateView, NewEventWizardFinishView, NewEventWizardSettingsView
 from AKModel.views.room import RoomBatchCreationView
@@ -44,6 +45,11 @@ if apps.is_installed("AKSubmission"):
     from AKSubmission.api import increment_interest_counter
     extra_paths.append(path('api/ak/<pk>/indicate-interest/', increment_interest_counter, name='submission-ak-indicate-interest'))
 
+# If AKSolverInterface is active, register additional API endpoints
+if apps.is_installed("AKSolverInterface"):
+     from AKSolverInterface.api import ExportEventForSolverViewSet
+     api_router.register("solver-export", ExportEventForSolverViewSet, basename="solver-export")
+
 event_specific_paths = [
     path('api/', include(api_router.urls), name='api'),
 ]
@@ -103,6 +109,8 @@ def get_admin_urls_event(admin_site):
         path('<slug:event_slug>/ak-slide-export/', admin_site.admin_view(ExportSlidesView.as_view()), name="ak_slide_export"),
         path('plan/publish/', admin_site.admin_view(PlanPublishView.as_view()), name="plan-publish"),
         path('plan/unpublish/', admin_site.admin_view(PlanUnpublishView.as_view()), name="plan-unpublish"),
+        path('poll/publish/', admin_site.admin_view(PollPublishView.as_view()), name="poll-publish"),
+        path('poll/unpublish/', admin_site.admin_view(PollUnpublishView.as_view()), name="poll-unpublish"),
         path('<slug:event_slug>/defaultSlots/', admin_site.admin_view(DefaultSlotEditorView.as_view()),
              name="default-slots-editor"),
         path('<slug:event_slug>/importRooms/', admin_site.admin_view(RoomBatchCreationView.as_view()),

AKModel/views/manage.py

@@ -4,6 +4,7 @@ import os
 import tempfile
 from itertools import zip_longest
 
+
 from django.contrib import messages
 from django.db.models.functions import Now
 from django.utils.dateparse import parse_datetime
@@ -14,7 +15,7 @@ from django_tex.response import PDFResponse
 
 from AKModel.forms import SlideExportForm, DefaultSlotEditorForm
 from AKModel.metaviews.admin import EventSlugMixin, IntermediateAdminView, IntermediateAdminActionView, AdminViewMixin
-from AKModel.models import ConstraintViolation, Event, DefaultSlot, AKOwner
+from AKModel.models import ConstraintViolation, Event, DefaultSlot, AKOwner, AKType
 
 
 class UserView(TemplateView):
@@ -35,6 +36,18 @@ class ExportSlidesView(EventSlugMixin, IntermediateAdminView):
     title = _('Export AK Slides')
     form_class = SlideExportForm
 
+    def get_form(self, form_class=None):
+        # Filter type choices to those of the current event
+        # or completely hide the field if no types are specified for this event
+        form = super().get_form(form_class)
+        if self.event.aktype_set.count() > 0:
+            form.fields['types'].choices = [
+                (ak_type.id, ak_type.name) for ak_type in self.event.aktype_set.all()
+            ]
+        else:
+            form.fields['types'].widget = form.fields['types'].hidden_widget()
+        return form
+
     def form_valid(self, form):
         # pylint: disable=invalid-name
         template_name = 'admin/AKModel/export/slides.tex'
@@ -51,6 +64,7 @@ class ExportSlidesView(EventSlugMixin, IntermediateAdminView):
             'reso': _("Reso intention?"),
             'category': _("Category (for Wishes)"),
             'wishes': _("Wishes"),
+            'types': _("Types"),
         }
 
         def build_ak_list_with_next_aks(ak_list):
@@ -58,23 +72,34 @@ class ExportSlidesView(EventSlugMixin, IntermediateAdminView):
             Create a list of tuples cosisting of an AK and a list of upcoming AKs (list length depending on setting)
             """
             next_aks_list = zip_longest(*[ak_list[i + 1:] for i in range(NEXT_AK_LIST_LENGTH)], fillvalue=None)
-            return [(ak, next_aks) for ak, next_aks in zip_longest(ak_list, next_aks_list, fillvalue=[])]
+            return list(zip_longest(ak_list, next_aks_list, fillvalue=[]))
+
+        # Create a list of types to filter AKs by (if at least one type was selected)
+        types = None
+        types_filter_string = ""
+        show_types = self.event.aktype_set.count() > 0
+        if len(form.cleaned_data['types']) > 0:
+            types = AKType.objects.filter(id__in=form.cleaned_data['types'])
+            names_string = ', '.join(AKType.objects.get(pk=t).name for t in form.cleaned_data['types'])
+            types_filter_string = f"[{_('Type(s)')}: {names_string}]"
 
         # Get all relevant AKs (wishes separately, and either all AKs or only those who should directly or indirectly
         # be presented when restriction setting was chosen)
         categories_with_aks, ak_wishes = self.event.get_categories_with_aks(wishes_seperately=True, filter_func=lambda
-            ak: not RESULT_PRESENTATION_MODE or (ak.present or (ak.present is None and ak.category.present_by_default)))
+            ak: not RESULT_PRESENTATION_MODE or (ak.present or (ak.present is None and ak.category.present_by_default)),
+                                                                            types=types)
 
         # Create context for LaTeX rendering
         context = {
             'title': self.event.name,
             'categories_with_aks': [(category, build_ak_list_with_next_aks(ak_list)) for category, ak_list in
                                     categories_with_aks],
-            'subtitle': _("AKs"),
+            'subtitle': _("AKs") + " " + types_filter_string,
             "wishes": build_ak_list_with_next_aks(ak_wishes),
             "translations": translations,
             "result_presentation_mode": RESULT_PRESENTATION_MODE,
             "space_for_notes_in_wishes": SPACE_FOR_NOTES_IN_WISHES,
+            "show_types": show_types,
         }
 
         source = render_template_with_context(template_name, context)
@@ -157,6 +182,31 @@ class PlanUnpublishView(IntermediateAdminActionView):
         self.entities.update(plan_published_at=None, plan_hidden=True)
 
 
+class PollPublishView(IntermediateAdminActionView):
+    """
+    Admin action view: Publish the preference poll of one or multitple event(s)
+    """
+    title = _('Publish preference poll')
+    model = Event
+    confirmation_message = _('Publish the poll(s) of:')
+    success_message = _('Preference poll published')
+
+    def action(self, form):
+        self.entities.update(poll_published_at=Now(), poll_hidden=False)
+
+
+class PollUnpublishView(IntermediateAdminActionView):
+    """
+    Admin action view: Unpublish the preference poll of one or multitple event(s)
+    """
+    title = _('Unpublish preference poll')
+    model = Event
+    confirmation_message = _('Unpublish the preference poll(s) of:')
+    success_message = _('Preference poll unpublished')
+
+    def action(self, form):
+        self.entities.update(poll_published_at=None, poll_hidden=True)
+
 class DefaultSlotEditorView(EventSlugMixin, IntermediateAdminView):
     """
     Admin view: Allow to edit the default slots of an event

AKModel/views/status.py

@@ -152,6 +152,17 @@ class EventAKsWidget(TemplateStatusWidget):
                 },
             ]
         )
+        if apps.is_installed("AKSolverInterface"):
+            actions.extend([
+                {
+                    "text": _("Export AKs as JSON"),
+                    "url": reverse_lazy("admin:ak_json_export", kwargs={"event_slug": context["event"].slug}),
+                },
+                {
+                    "text": _("Import AK schedule from JSON"),
+                    "url": reverse_lazy("admin:ak_schedule_json_import", kwargs={"event_slug": context["event"].slug}),
+                },
+            ])
         return actions
 
 

AKPlan/locale/de_DE/LC_MESSAGES/django.po

@@ -8,7 +8,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: PACKAGE VERSION\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2023-05-15 20:03+0200\n"
+"POT-Creation-Date: 2025-06-16 12:44+0200\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <LL@li.org>\n"
@@ -38,45 +38,65 @@ msgstr "Veranstaltung"
 #: AKPlan/templates/AKPlan/plan_index.html:59
 #: AKPlan/templates/AKPlan/plan_room.html:13
 #: AKPlan/templates/AKPlan/plan_room.html:59
-#: AKPlan/templates/AKPlan/plan_wall.html:65
+#: AKPlan/templates/AKPlan/plan_wall.html:67
 msgid "Room"
 msgstr "Raum"
 
-#: AKPlan/templates/AKPlan/plan_index.html:80
+#: AKPlan/templates/AKPlan/plan_index.html:120
 #: AKPlan/templates/AKPlan/plan_room.html:11
 #: AKPlan/templates/AKPlan/plan_track.html:9
 msgid "AK Plan"
 msgstr "AK-Plan"
 
-#: AKPlan/templates/AKPlan/plan_index.html:92
+#: AKPlan/templates/AKPlan/plan_index.html:134
 #: AKPlan/templates/AKPlan/plan_room.html:49
 msgid "Rooms"
 msgstr "Räume"
 
-#: AKPlan/templates/AKPlan/plan_index.html:105
+#: AKPlan/templates/AKPlan/plan_index.html:147
 #: AKPlan/templates/AKPlan/plan_track.html:36
 msgid "Tracks"
 msgstr "Tracks"
 
-#: AKPlan/templates/AKPlan/plan_index.html:117
+#: AKPlan/templates/AKPlan/plan_index.html:159
 msgid "AK Wall"
 msgstr "AK-Wall"
 
-#: AKPlan/templates/AKPlan/plan_index.html:130
-#: AKPlan/templates/AKPlan/plan_wall.html:130
+#: AKPlan/templates/AKPlan/plan_index.html:165
+msgid "Plan:"
+msgstr "Plan:"
+
+#: AKPlan/templates/AKPlan/plan_index.html:171
+msgid "Filter by types"
+msgstr "Nach Typen filtern"
+
+#: AKPlan/templates/AKPlan/plan_index.html:174
+msgid "Types:"
+msgstr "Typen:"
+
+#: AKPlan/templates/AKPlan/plan_index.html:182
+msgid "AKs without type"
+msgstr "AKs ohne Typ"
+
+#: AKPlan/templates/AKPlan/plan_index.html:186
+msgid "No AKs with additional other types"
+msgstr "Keine AKs, die noch zusätzlich andere Typen haben"
+
+#: AKPlan/templates/AKPlan/plan_index.html:198
+#: AKPlan/templates/AKPlan/plan_wall.html:132
 msgid "Current AKs"
 msgstr "Aktuelle AKs"
 
-#: AKPlan/templates/AKPlan/plan_index.html:137
-#: AKPlan/templates/AKPlan/plan_wall.html:135
+#: AKPlan/templates/AKPlan/plan_index.html:205
+#: AKPlan/templates/AKPlan/plan_wall.html:137
 msgid "Next AKs"
 msgstr "Nächste AKs"
 
-#: AKPlan/templates/AKPlan/plan_index.html:145
+#: AKPlan/templates/AKPlan/plan_index.html:213
 msgid "This event is not active."
 msgstr "Dieses Event ist nicht aktiv."
 
-#: AKPlan/templates/AKPlan/plan_index.html:158
+#: AKPlan/templates/AKPlan/plan_index.html:226
 #: AKPlan/templates/AKPlan/plan_room.html:77
 #: AKPlan/templates/AKPlan/plan_track.html:58
 msgid "Plan is not visible (yet)."
@@ -99,10 +119,14 @@ msgstr "Eigenschaften"
 msgid "Track"
 msgstr "Track"
 
-#: AKPlan/templates/AKPlan/plan_wall.html:145
+#: AKPlan/templates/AKPlan/plan_wall.html:147
 msgid "Reload page automatically?"
 msgstr "Seite automatisch neu laden?"
 
 #: AKPlan/templates/AKPlan/slots_table.html:14
 msgid "No AKs"
 msgstr "Keine AKs"
+
+#: AKPlan/views.py:64
+msgid "Invalid type filter"
+msgstr "Ungültiger Typ-Filter"

AKPlan/templates/AKPlan/plan_index.html

@@ -70,6 +70,46 @@
                 }
             });
         </script>
+
+        {% if type_filtering_active %}
+            {# Type filter script #}
+            <script type="module">
+                const { createApp } = Vue
+
+                createApp({
+                    delimiters: ["[[", "]]"],
+                    data() {
+                      return {
+                          types: JSON.parse("{{ types | escapejs }}"),
+                          strict: {{ types_filter_strict|yesno:"true,false" }},
+                          empty: {{ types_filter_empty|yesno:"true,false" }}
+                      }
+                    },
+                    methods: {
+                        onFilterChange(type) {
+                            // Re-generate filter url
+                            const typeString = "types="
+                                + this.types
+                                .map(t => `${t.slug}:${t.state ? 'yes' : 'no'}`)
+                                .join(',')
+                                + `&strict=${this.strict ? 'yes' : 'no'}`
+                                + `&empty=${this.empty ? 'yes' : 'no'}`;
+
+                            // Redirect to the new url including the adjusted filters
+                            const baseUrl = window.location.origin + window.location.pathname;
+                            window.location.href = `${baseUrl}?${typeString}`;
+                          }
+                    }
+                }).mount('#filter');
+
+                // Prevent showing of cached form values for filter inputs when using broswer navigation
+                window.addEventListener('pageshow', function(event) {
+                  if (event.persisted) {
+                    window.location.reload();
+                  }
+                });
+            </script>
+        {% endif %}
     {% endif %}
 {% endblock %}
 
@@ -83,6 +123,8 @@
 
 
 {% block content %}
+    {% include "messages.html" %}
+
     <div class="float-end">
         <ul class="nav nav-pills">
             {% if rooms|length > 0 %}
@@ -114,13 +156,39 @@
             {% if event.active %}
                 <li class="nav-item">
                     <a class="nav-link active"
-                       href="{% url 'plan:plan_wall' event_slug=event.slug %}">{% fa6_icon 'desktop' 'fas' %}&nbsp;&nbsp;{% trans "AK Wall" %}</a>
+                       href="{% url 'plan:plan_wall' event_slug=event.slug %}?{{ query_string }}">{% fa6_icon 'desktop' 'fas' %}&nbsp;&nbsp;{% trans "AK Wall" %}</a>
                 </li>
             {% endif %}
         </ul>
     </div>
 
-    <h1>Plan: {{ event }}</h1>
+    <h1 class="mb-3">{%  trans "Plan:" %} {{ event }}</h1>
+
+    {% if type_filtering_active %}
+        {# Type filter HTML #}
+        <div class="card border-primary mb-3">
+            <div class="card-header">
+                {% trans 'Filter by types' %}
+            </div>
+            <div class="card-body d-flex" id="filter">
+                {% trans "Types:" %}
+                <div id="filterTypes" class="d-flex">
+                    <div class="form-check form-switch ms-3"  v-for="type in types">
+                        <label class="form-check-label" :for="'typeFilterType' + type.slug">[[ type.name ]]</label>
+                        <input class="form-check-input" type="checkbox" :id="'typeFilterType' + type.slug " v-model="type.state" @change="onFilterChange()">
+                    </div>
+                </div>
+                <div class="form-check form-switch ms-5">
+                    <label class="form-check-label" for="typeFilterEmpty">{% trans "AKs without type" %}</label>
+                    <input class="form-check-input" type="checkbox" id="typeFilterEmpty" v-model="empty" @change="onFilterChange()">
+                </div>
+                <div class="form-check form-switch ms-5">
+                    <label class="form-check-label" for="typeFilterStrict">{% trans "No AKs with additional other types" %}</label>
+                    <input class="form-check-input" type="checkbox" id="typeFilterStrict" v-model="strict" @change="onFilterChange()">>
+                </div>
+            </div>
+        </div>
+    {% endif %}
 
     {% timezone event.timezone %}
         <div class="row" style="margin-top:30px;">

AKPlan/tests.py

 from django.test import TestCase
 
-from AKModel.tests import BasicViewTests
+from AKModel.tests.test_views import BasicViewTests
 
 
 class PlanViewTests(BasicViewTests, TestCase):

AKPlan/views.py

-from datetime import timedelta
+import json
+from datetime import datetime, timedelta
 
 from django.conf import settings
+from django.contrib import messages
+from django.db.models import Q
 from django.shortcuts import redirect
 from django.urls import reverse_lazy
-from django.utils.datetime_safe import datetime
-from django.views.generic import ListView, DetailView
+from django.views.generic import DetailView, ListView
+from django.utils.translation import gettext_lazy as _
 
-from AKModel.models import AKSlot, Room, AKTrack
 from AKModel.metaviews.admin import FilterByEventSlugMixin
+from AKModel.models import AKSlot, AKTrack, Room, AKType
 
 
 class PlanIndexView(FilterByEventSlugMixin, ListView):
@@ -20,10 +23,69 @@ class PlanIndexView(FilterByEventSlugMixin, ListView):
     template_name = "AKPlan/plan_index.html"
     context_object_name = "akslots"
     ordering = "start"
+    types_filter = None
+    query_string = ""
+
+    def get(self, request, *args, **kwargs):
+        if 'types' in request.GET:
+            try:
+                # Initialize types filter, has to be done here such that it is not reused across requests
+                self.types_filter = {
+                    "yes": [],
+                    "no": [],
+                    "no_set": set(),
+                    "strict": False,
+                    "empty": False,
+                }
+                # If types are given, filter the queryset accordingly
+                types_raw = request.GET['types'].split(',')
+                for t in types_raw:
+                    type_slug, type_condition = t.split(':')
+                    if type_condition in ["yes", "no"]:
+                        t = AKType.objects.get(slug=type_slug, event=self.event)
+                        self.types_filter[type_condition].append(t)
+                        if type_condition == "no":
+                            # Store slugs of excluded types in a set for faster lookup
+                            self.types_filter["no_set"].add(t.slug)
+                    else:
+                        raise ValueError(f"Unknown type condition: {type_condition}")
+                if 'strict' in request.GET:
+                    # If strict is specified and marked as "yes",
+                    # exclude all AKs that have any of the excluded types ("no"),
+                    # even if they have other types that are marked as "yes"
+                    self.types_filter["strict"] = request.GET.get('strict') == 'yes'
+                if 'empty' in request.GET:
+                    # If empty is specified and marked as "yes", include AKs that have no types at all
+                    self.types_filter["empty"] = request.GET.get('empty') == 'yes'
+                # Will be used for generating a link to the wall view with the same filter
+                self.query_string = request.GET.urlencode(safe=",:")
+            except (ValueError, AKType.DoesNotExist):
+                # Display an error message if the types parameter is malformed
+                messages.add_message(request, messages.ERROR, _("Invalid type filter"))
+                self.types_filter = None
+        s = super().get(request, *args, **kwargs)
+        return s
 
     def get_queryset(self):
         # Ignore slots not scheduled yet
-        return super().get_queryset().filter(start__isnull=False).select_related('ak', 'room', 'ak__category')
+        qs = (super().get_queryset().filter(start__isnull=False).
+                select_related('event', 'ak', 'room', 'ak__category', 'ak__event'))
+                # Need to prefetch both event and ak__event
+                # since django is not aware that the two are always the same
+
+        # Apply type filter if necessary
+        if self.types_filter:
+            # Either include all AKs with the given types or without any types at all
+            if self.types_filter["empty"]:
+                qs = qs.filter(Q(ak__types__in=self.types_filter["yes"]) | Q(ak__types__isnull=True)).distinct()
+            # Or only those with the given types
+            else:
+                qs = qs.filter(ak__types__in=self.types_filter["yes"]).distinct()
+            # Afterwards, if strict, exclude all AKs that have any of the excluded types,
+            # even though they were included by the previous filter
+            if self.types_filter["strict"]:
+                qs = qs.exclude(ak__types__in=self.types_filter["no"]).distinct()
+        return qs
 
     def get_context_data(self, *, object_list=None, **kwargs):
         context = super().get_context_data(object_list=object_list, **kwargs)
@@ -39,6 +101,7 @@ class PlanIndexView(FilterByEventSlugMixin, ListView):
 
         # Get list of current and next slots
         for akslot in context["akslots"]:
+            self._process_slot(akslot)
             # Construct a list of all rooms used by these slots on the fly
             if akslot.room is not None:
                 rooms.add(akslot.room)
@@ -61,8 +124,38 @@ class PlanIndexView(FilterByEventSlugMixin, ListView):
 
         context["tracks"] = self.event.aktrack_set.all()
 
+        # Pass query string to template for generating a matching wall link
+        context["query_string"] = self.query_string
+
+        # Generate a list of all types and their current selection state for graphic filtering
+        types = [{"name": t.name, "slug": t.slug, "state": True} for t in self.event.aktype_set.all()]
+        if len(types) > 0:
+            context["type_filtering_active"] = True
+            if self.types_filter:
+                for t in types:
+                    if t["slug"] in self.types_filter["no_set"]:
+                        t["state"] = False
+            # Pass type list as well as filter state for strict filtering and empty types to the template
+            context["types"] = json.dumps(types)
+            context["types_filter_strict"] = False
+            context["types_filter_empty"] = False
+            if self.types_filter:
+                context["types_filter_empty"] = self.types_filter["empty"]
+                context["types_filter_strict"] = self.types_filter["strict"]#
+        else:
+            context["type_filtering_active"] = False
+
         return context
 
+    def _process_slot(self, akslot):
+        """
+        Function to be called for each slot when looping over the slots
+        (meant to be overridden in inherited views)
+
+        :param akslot: current slot
+        :type akslot: AKSlot
+        """
+
 
 class PlanScreenView(PlanIndexView):
     """
@@ -96,26 +189,12 @@ class PlanScreenView(PlanIndexView):
 
         # Restrict AK slots to relevant ones
         # This will automatically filter all rooms not needed for the selected range in the orginal get_context method
-        akslots = super().get_queryset().filter(start__gt=self.start)
+        return super().get_queryset().filter(start__gt=self.start)
 
+    def get_context_data(self, *, object_list=None, **kwargs):
         # Find the earliest hour AKs start and end (handle 00:00 as 24:00)
         self.earliest_start_hour = 23
         self.latest_end_hour = 1
-        for akslot in akslots.all():
-            start_hour = akslot.start.astimezone(self.event.timezone).hour
-            if start_hour < self.earliest_start_hour:
-                # Use hour - 1 to improve visibility of date change
-                self.earliest_start_hour = max(start_hour - 1, 0)
-            end_hour = akslot.end.astimezone(self.event.timezone).hour
-            # Special case: AK starts before but ends after midnight -- show until midnight
-            if end_hour < start_hour:
-                self.latest_end_hour = 24
-            elif end_hour > self.latest_end_hour:
-                # Always use hour + 1, since AK may end at :xy and not always at :00
-                self.latest_end_hour = min(end_hour + 1, 24)
-        return akslots
-
-    def get_context_data(self, *, object_list=None, **kwargs):
         context = super().get_context_data(object_list=object_list, **kwargs)
         context["start"] = self.start
         context["end"] = self.event.end
@@ -123,6 +202,19 @@ class PlanScreenView(PlanIndexView):
         context["latest_end_hour"] = self.latest_end_hour
         return context
 
+    def _process_slot(self, akslot):
+        start_hour = akslot.start.astimezone(self.event.timezone).hour
+        if start_hour < self.earliest_start_hour:
+            # Use hour - 1 to improve visibility of date change
+            self.earliest_start_hour = max(start_hour - 1, 0)
+        end_hour = akslot.end.astimezone(self.event.timezone).hour
+        # Special case: AK starts before but ends after midnight -- show until midnight
+        if end_hour < start_hour:
+            self.latest_end_hour = 24
+        elif end_hour > self.latest_end_hour:
+            # Always use hour + 1, since AK may end at :xy and not always at :00
+            self.latest_end_hour = min(end_hour + 1, 24)
+
 
 class PlanRoomView(FilterByEventSlugMixin, DetailView):
     """
@@ -152,7 +244,7 @@ class PlanTrackView(FilterByEventSlugMixin, DetailView):
         context = super().get_context_data(object_list=object_list, **kwargs)
         # Restrict AKSlot list to given track
         # while joining AK, room and category information to reduce the amount of necessary SQL queries
-        context["slots"] = AKSlot.objects.\
-            filter(event=self.event, ak__track=context['track']).\
+        context["slots"] = AKSlot.objects. \
+            filter(event=self.event, ak__track=context['track']). \
             select_related('ak', 'room', 'ak__category')
         return context

AKPlanning/settings.py

@@ -10,6 +10,7 @@ For the full list of settings and their values, see
 https://docs.djangoproject.com/en/2.2/ref/settings/
 """
 
+import decimal
 import os
 
 from django.utils.translation import gettext_lazy as _
@@ -38,6 +39,8 @@ INSTALLED_APPS = [
     'AKScheduling.apps.AkschedulingConfig',
     'AKPlan.apps.AkplanConfig',
     'AKOnline.apps.AkonlineConfig',
+    'AKPreference.apps.AkpreferenceConfig',
+    'AKSolverInterface.apps.AksolverinterfaceConfig',
     'AKModel.apps.AKAdminConfig',
     'django.contrib.auth',
     'django.contrib.contenttypes',
@@ -221,6 +224,12 @@ DASHBOARD_RECENT_MAX = 25
 # (active events will always be featured, even if their number is higher than this threshold)
 DASHBOARD_MAX_FEATURED_EVENTS = 3
 
+# In the export to the solver we need to calculate the integer number
+# of discrete time slots covered by an AK. This is done by rounding
+# the 'exact' number up. To avoid 'overshooting' by 1
+# due to FLOP inaccuracies, we subtract this small epsilon before rounding.
+EXPORT_CEIL_OFFSET_EPS = decimal.Decimal(1e-4)
+
 # Registration/login behavior
 SIMPLE_BACKEND_REDIRECT_URL = "/user/"
 LOGIN_REDIRECT_URL = SIMPLE_BACKEND_REDIRECT_URL

AKPlanning/urls.py

@@ -37,3 +37,5 @@ if apps.is_installed("AKDashboard"):
     urlpatterns.append(path('', include('AKDashboard.urls', namespace='dashboard')))
 if apps.is_installed("AKPlan"):
     urlpatterns.append(path('', include('AKPlan.urls', namespace='plan')))
+if apps.is_installed("AKPreference"):
+    urlpatterns.append(path('', include('AKPreference.urls', namespace='poll')))

AKPreference/admin.py

+from django import forms
+from django.contrib import admin
+
+from AKPreference.models import AKPreference, EventParticipant
+from AKModel.admin import PrepopulateWithNextActiveEventMixin
+from AKModel.models import AK
+
+@admin.register(EventParticipant)
+class EventParticipantAdmin(PrepopulateWithNextActiveEventMixin, admin.ModelAdmin):
+    """
+    Admin interface for EventParticipant
+    """
+    model = EventParticipant
+    list_display = ['name', 'institution', 'event']
+    list_filter = ['event', 'institution']
+    list_editable = []
+    ordering = ['name']
+
+
+class AKPreferenceAdminForm(forms.ModelForm):
+    """
+    Adapted admin form for AK preferences for usage in :class:`AKPreferenceAdmin`)
+    """
+    class Meta:
+        widgets = {
+            'participant': forms.Select,
+            'ak': forms.Select,
+        }
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        # Filter possible values for foreign keys & m2m when event is specified
+        if hasattr(self.instance, "event") and self.instance.event is not None:
+            self.fields["participant"].queryset = EventParticipant.objects.filter(event=self.instance.event)
+            self.fields["ak"].queryset = AK.objects.filter(event=self.instance.event)
+
+
+@admin.register(AKPreference)
+class AKPreferenceAdmin(PrepopulateWithNextActiveEventMixin, admin.ModelAdmin):
+    """
+    Admin interface for AK preferences.
+    Uses an adapted form (see :class:`AKPreferenceAdminForm`)
+    """
+    model = AKPreference
+    form = AKPreferenceAdminForm
+    list_display = ['preference', 'participant', 'ak', 'event']
+    list_filter = ['event', 'ak', 'participant']
+    list_editable = []
+    ordering = ['participant', 'preference', 'ak']