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',
@@ -217,6 +220,15 @@ PLAN_MAX_HIGHLIGHT_UPDATE_SECONDS = 2 * 60 * 60
 DASHBOARD_SHOW_RECENT = True
 # How many entries max?
 DASHBOARD_RECENT_MAX = 25
+# How many events should be featured in the dashboard
+# (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/"
@@ -224,7 +236,7 @@ LOGIN_REDIRECT_URL = SIMPLE_BACKEND_REDIRECT_URL
 
 # Content Security Policy
 CSP_DEFAULT_SRC = ("'self'",)
-CSP_SCRIPT_SRC = ("'self'", "'unsafe-inline'")
+CSP_SCRIPT_SRC = ("'self'", "'unsafe-inline'", "'unsafe-eval'")
 CSP_STYLE_SRC = ("'self'", "'unsafe-inline'", "fonts.googleapis.com")
 CSP_IMG_SRC = ("'self'", "data:")
 CSP_FRAME_SRC = ("'self'", )

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']

AKPreference/apps.py

+from django.apps import AppConfig
+
+
+class AkpreferenceConfig(AppConfig):
+    """
+    App configuration (default, only specifies name of the app)
+    """
+
+    name = "AKPreference"

AKPreference/forms.py

+from django import forms
+from django.utils.translation import gettext_lazy as _
+
+from AKModel.availability.forms import AvailabilitiesFormMixin
+from AKModel.availability.models import Availability
+from AKModel.models import AKRequirement
+from AKPreference.models import EventParticipant
+
+
+class EventParticipantForm(AvailabilitiesFormMixin, forms.ModelForm):
+    """Form to add EventParticipants"""
+
+    required_css_class = "required"
+
+    class Meta:
+        model = EventParticipant
+        fields = [
+            "name",
+            "institution",
+            "requirements",
+            "event",
+        ]
+        widgets = {
+            "requirements": forms.CheckboxSelectMultiple,
+            "event": forms.HiddenInput,
+        }
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.initial = {**self.initial, **kwargs["initial"]}
+
+        self.fields["requirements"].queryset = AKRequirement.objects.filter(
+            event=self.initial.get("event")
+        )
+        # Don't ask for requirements if there are no requirements configured for this event
+        if self.fields["requirements"].queryset.count() == 0:
+            self.fields.pop("requirements")
+
+    def clean_availabilities(self):
+        """
+        Automatically improve availabilities entered.
+        If the user did not specify availabilities assume the full event duration is possible
+        :return: cleaned availabilities
+        (either user input or one availability for the full length of the event if user input was empty)
+        """
+        availabilities = super().clean_availabilities()
+        if len(availabilities) == 0:
+            availabilities.append(
+                Availability.with_event_length(event=self.cleaned_data["event"])
+            )
+        return availabilities

AKPreference/locale/de_DE/LC_MESSAGES/django.po

+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
+# This file is distributed under the same license as the PACKAGE package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2025-06-13 23:58+0000\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"
+"Language: \n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: AKPreference/templates/AKPreference/poll.html:11
+#: AKPreference/templates/AKPreference/poll_not_configured.html:7
+msgid "AKs"
+msgstr "AKs"
+
+#: AKPreference/templates/AKPreference/poll.html:11
+msgid "Preferences"
+msgstr "Präferenzen"
+
+#: AKPreference/templates/AKPreference/poll.html:34
+#: AKPreference/templates/AKPreference/poll.html:41
+msgid "AK Preferences"
+msgstr "AK-Präferenzen"
+
+#: AKPreference/templates/AKPreference/poll.html:47
+msgid "Your preferences"
+msgstr "Deine Präferenzen"
+
+#: AKPreference/templates/AKPreference/poll.html:49
+msgid "Please enter your preferences."
+msgstr "Trage bitte deine Präferenzen zu den AKs ein."
+
+#: AKPreference/templates/AKPreference/poll.html:68
+#: AKPreference/templates/AKPreference/poll.html:82
+msgid "Intends to submit a resolution"
+msgstr "Beabsichtigt eine Resolution einzureichen"
+
+#: AKPreference/templates/AKPreference/poll.html:73
+msgid "Description"
+msgstr "Beschreibung"
+
+#: AKPreference/templates/AKPreference/poll.html:78
+msgid "Responsible"
+msgstr "Verantwortlich"
+
+#: AKPreference/templates/AKPreference/poll.html:93
+msgid "Submit"
+msgstr "Eintragen"
+
+#: AKPreference/templates/AKPreference/poll.html:97
+msgid "Reset Form"
+msgstr "Formular leeren"
+
+#: AKPreference/templates/AKPreference/poll.html:101
+msgid "Cancel"
+msgstr "Abbrechen"
+
+#: AKPreference/templates/AKPreference/poll_base.html:13
+msgid "Write to organizers of this event for questions and comments"
+msgstr "Fragen oder Kommentare? Schreib den Orgas dieses Events eine Mail"
+
+#: AKPreference/templates/AKPreference/poll_not_configured.html:7
+#: AKPreference/templates/AKPreference/poll_not_configured.html:11
+msgid "AK Preference Poll"
+msgstr "Abfrage von AK-Präferenzen"
+
+#: AKPreference/templates/AKPreference/poll_not_configured.html:20
+msgid ""
+"System is not yet configured for AK preference polling. Please try again "
+"later."
+msgstr ""
+"Das System ist bisher nicht für die Erfassung von AK-Präferenzen "
+"konfiguriert. Bitte versuche es später wieder."
+
+#: AKPreference/views.py:18
+msgid "AK preferences were registered successfully"
+msgstr "AK-Präferenzen erfolgreich registriert"
+
+#: AKPreference/views.py:113
+msgid ""
+"Something went wrong. Your preferences were not saved. Please try again or "
+"contact the organizers."
+msgstr ""
+"Etwas ging schief. Deine Präferenzen konnten nicht gespeichert werden. "
+"Versuche es bitte erneut oder kontaktiere die Orgas."

AKPreference/migrations/0001_initial.py

+# Generated by Django 5.2.1 on 2025-06-14 18:57
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ("AKModel", "0067_eventparticipant_requirements_and_more"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="EventParticipant",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                (
+                    "name",
+                    models.CharField(
+                        blank=True,
+                        help_text="Name to identify a participant by (in case of questions from the organizers)",
+                        max_length=64,
+                        verbose_name="Nickname",
+                    ),
+                ),
+                (
+                    "institution",
+                    models.CharField(
+                        blank=True,
+                        help_text="Uni etc.",
+                        max_length=128,
+                        verbose_name="Institution",
+                    ),
+                ),
+                (
+                    "event",
+                    models.ForeignKey(
+                        help_text="Associated event",
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="AKModel.event",
+                        verbose_name="Event",
+                    ),
+                ),
+                (
+                    "requirements",
+                    models.ManyToManyField(
+                        blank=True,
+                        help_text="Participant's Requirements",
+                        to="AKModel.akrequirement",
+                        verbose_name="Requirements",
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "Participant",
+                "verbose_name_plural": "Participants",
+                "ordering": ["name"],
+            },
+        ),
+        migrations.CreateModel(
+            name="AKPreference",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                (
+                    "preference",
+                    models.PositiveSmallIntegerField(
+                        choices=[
+                            (0, "Ignore"),
+                            (1, "Interested"),
+                            (2, "Great interest"),
+                            (3, "Required"),
+                        ],
+                        default=0,
+                        help_text="Preference level for the AK",
+                        verbose_name="Preference",
+                    ),
+                ),
+                (
+                    "timestamp",
+                    models.DateTimeField(
+                        auto_now_add=True,
+                        help_text="Time of creation",
+                        verbose_name="Timestamp",
+                    ),
+                ),
+                (
+                    "ak",
+                    models.ForeignKey(
+                        help_text="AK this preference belongs to",
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="AKModel.ak",
+                        verbose_name="AK",
+                    ),
+                ),
+                (
+                    "event",
+                    models.ForeignKey(
+                        help_text="Associated event",
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="AKModel.event",
+                        verbose_name="Event",
+                    ),
+                ),
+                (
+                    "participant",
+                    models.ForeignKey(
+                        help_text="Participant this preference belongs to",
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="AKPreference.eventparticipant",
+                        verbose_name="Participant",
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "AK Preference",
+                "verbose_name_plural": "AK Preferences",
+                "ordering": ["-timestamp"],
+                "unique_together": {("event", "participant", "ak")},
+            },
+        ),
+    ]

AKPreference/models.py

+from django.db import models
+from django.utils.translation import gettext_lazy as _
+
+from AKModel.models import AK, AKRequirement, Event
+
+
+class EventParticipant(models.Model):
+    """ A participant describes a person taking part in an event."""
+
+    class Meta:
+        verbose_name = _('Participant')
+        verbose_name_plural = _('Participants')
+        ordering = ['name']
+
+    name = models.CharField(max_length=64, blank=True, verbose_name=_('Nickname'),
+                            help_text=_('Name to identify a participant by (in case of questions from the organizers)'))
+    institution = models.CharField(max_length=128, blank=True, verbose_name=_('Institution'), help_text=_('Uni etc.'))
+
+    event = models.ForeignKey(to=Event, on_delete=models.CASCADE, verbose_name=_('Event'),
+                              help_text=_('Associated event'))
+
+    requirements = models.ManyToManyField(to=AKRequirement, blank=True, verbose_name=_('Requirements'),
+                                          help_text=_("Participant's Requirements"))
+
+    def __str__(self) -> str:
+        string = _("Anonymous {pk}").format(pk=self.pk) if not self.name else self.name
+        if self.institution:
+            string += f" ({self.institution})"
+        return string
+
+    @property
+    def availabilities(self):
+        """
+        Get all availabilities associated to this EventParticipant
+        :return: availabilities
+        :rtype: QuerySet[Availability]
+        """
+        return "Availability".objects.filter(participant=self)
+
+    def get_time_constraints(self) -> list[str]:
+        """Construct list of required time constraint labels."""
+        # local import to prevent cyclic import
+        # pylint: disable=import-outside-toplevel
+        from AKModel.availability.models import Availability
+
+        avails = self.availabilities.all()
+        participant_required_prefs = AKPreference.objects.filter(
+            event=self.event,
+            participant=self,
+            preference=AKPreference.PreferenceLevel.REQUIRED,
+        )
+
+        if (
+            avails
+            and not Availability.is_event_covered(self.event, avails)
+            and participant_required_prefs.exists()
+        ):
+            # participant has restricted availability and is actually required for AKs
+            return [f"availability-participant-{self.pk}"]
+
+        return []
+
+    def get_room_constraints(self) -> list[str]:
+        """Construct list of required room constraint labels."""
+        return list(self.requirements.values_list("name", flat=True).order_by())
+
+    @property
+    def export_preferences(self):
+        """Preferences of this participant with positive score."""
+        return (
+            AKPreference.objects
+            .filter(
+                participant=self, preference__gt=0
+            )
+            .order_by()
+            .select_related('ak')
+            .prefetch_related('ak__akslot_set')
+        )
+
+
+class AKPreference(models.Model):
+    """Model representing the preference of a participant to an AK."""
+
+    class Meta:
+        verbose_name = _('AK Preference')
+        verbose_name_plural = _('AK Preferences')
+        unique_together = [['event', 'participant', 'ak']]
+        ordering = ["-timestamp"]
+
+    event = models.ForeignKey(to=Event, on_delete=models.CASCADE, verbose_name=_('Event'),
+                              help_text=_('Associated event'))
+
+    participant = models.ForeignKey(to=EventParticipant, on_delete=models.CASCADE, verbose_name=_('Participant'),
+                              help_text=_('Participant this preference belongs to'))
+
+    ak = models.ForeignKey(to=AK, on_delete=models.CASCADE, verbose_name=_('AK'),
+                           help_text=_('AK this preference belongs to'))
+
+    class PreferenceLevel(models.IntegerChoices):
+        """
+        Possible preference values
+        """
+        IGNORE = 0, _('Ignore')
+        PREFER = 1, _('Interested')
+        STRONG_PREFER = 2, _("Great interest")
+        REQUIRED = 3, _("Required")
+
+    preference = models.PositiveSmallIntegerField(verbose_name=_('Preference'), choices=PreferenceLevel.choices,
+                                             help_text=_('Preference level for the AK'),
+                                             blank=False,
+                                             default=PreferenceLevel.IGNORE)
+
+    timestamp = models.DateTimeField(auto_now_add=True, verbose_name=_('Timestamp'), help_text=_('Time of creation'))
+
+    def __str__(self) -> str:
+        return f"Preference {self.get_preference_display()} [of '{self.participant}' for AK '{self.ak}']"
+
+    @property
+    def required(self) -> bool:
+        """Whether this preference is a 'REQUIRED'"""
+        return self.preference == self.PreferenceLevel.REQUIRED
+
+    @property
+    def preference_score(self) -> int:
+        """Score of this preference for the solver"""
+        return self.preference if self.preference != self.PreferenceLevel.REQUIRED else -1

AKPreference/serializers.py

+from rest_framework import serializers
+
+from AKModel.models import AKSlot
+from AKModel.serializers import StringListField
+from AKPreference.models import AKPreference, EventParticipant
+
+class ExportAKPreferenceSerializer(serializers.ModelSerializer):
+    """Export serializer for AKPreference objects.
+
+    Used to serialize AKPreference objects for the export to a solver.
+    Part of the implementation of the format of the KoMa solver:
+    https://github.com/Die-KoMa/ak-plan-optimierung/wiki/Input-&-output-format#input--output-format
+    """
+
+    class Meta:
+        model = AKPreference
+        fields = ["required", "preference_score"]
+        read_only_fields = ["required", "preference_score"]
+
+
+class ExportAKPreferencePerSlotSerializer(serializers.BaseSerializer):
+    """Export serializer to associate AKPreferences with the AK's AKSlot objects.
+
+    The AKPreference model stores the preference per AK object.
+    The solver however needs the serialization to be *per AKSlot*, i.e.
+    we need to 'repeat' all preferences for each slot of an AK.
+
+    Part of the implementation of the format of the KoMa solver:
+    https://github.com/Die-KoMa/ak-plan-optimierung/wiki/Input-&-output-format#input--output-format
+    """
+
+    def create(self, validated_data):
+        raise ValueError("`ExportAKPreferencePerSlotSerializer` is read-only.")
+
+    def to_internal_value(self, data):
+        raise ValueError("`ExportAKPreferencePerSlotSerializer` is read-only.")
+
+    def update(self, instance, validated_data):
+        raise ValueError("`ExportAKPreferencePerSlotSerializer` is read-only.")
+
+    def to_representation(self, instance):
+        preference_queryset = instance
+
+        def _insert_akslot_id(serialization_dict: dict, slot: AKSlot) -> dict:
+            """Insert id of the slot into the dict and return it."""
+
+            # The naming scheme of the solver is confusing.
+            # Our 'AKSlot' corresponds to the 'AK' of the solver,
+            # so `ak_id` is the id of the corresponding AKSlot.
+            serialization_dict["ak_id"] = slot.pk
+            return serialization_dict
+
+        return_lst = []
+        for pref in preference_queryset:
+            pref_serialization = ExportAKPreferenceSerializer(pref).data
+            return_lst.extend([
+                _insert_akslot_id(pref_serialization, slot)
+                for slot in pref.ak.akslot_set.all()
+            ])
+        return return_lst
+
+
+class ExportParticipantInfoSerializer(serializers.ModelSerializer):
+    """Serializer of EventParticipant objects for the 'info' field.
+
+    Used in `ExportParticipantSerializer` to serialize EventParticipant objects
+    for the export to a solver. Part of the implementation of the
+    format of the KoMa solver:
+    https://github.com/Die-KoMa/ak-plan-optimierung/wiki/Input-&-output-format#input--output-format
+    """
+    name = serializers.CharField(source="__str__")
+
+    class Meta:
+        model = EventParticipant
+        fields = ["name"]
+        read_only_fields = ["name"]
+
+
+class ExportParticipantSerializer(serializers.ModelSerializer):
+    """Export serializer for EventParticipant objects.
+
+    Used to serialize EventParticipant objects for the export to a solver.
+    Part of the implementation of the format of the KoMa solver:
+    https://github.com/Die-KoMa/ak-plan-optimierung/wiki/Input-&-output-format#input--output-format
+    """
+
+    room_constraints = StringListField(source="get_room_constraints")
+    time_constraints = StringListField(source="get_time_constraints")
+    preferences = ExportAKPreferencePerSlotSerializer(source="export_preferences")
+    info = ExportParticipantInfoSerializer(source="*")
+
+    class Meta:
+        model = EventParticipant
+        fields = ["id", "info", "room_constraints", "time_constraints", "preferences"]
+        read_only_fields = ["id", "info", "room_constraints", "time_constraints", "preferences"]

AKPreference/templates/AKPreference/poll.html

+{% extends 'AKPreference/poll_base.html' %}
+
+{% load i18n %}
+{% load django_bootstrap5 %}
+{% load fontawesome_6 %}
+{% load static %}
+{% load tz %}
+{% load static %}
+
+
+{% block title %}{% trans "AKs" %}: {{ event.name }} - {% trans "Preferences" %}{% endblock %}
+
+{% block imports %}
+  {% include "AKModel/load_fullcalendar_availabilities.html" %}
+
+  <link rel="stylesheet" type='text/css' href="{% static 'common/css/poll.css' %}">
+
+  <script>
+    {% get_current_language as LANGUAGE_CODE %}
+
+    document.addEventListener('DOMContentLoaded', function () {
+      createAvailabilityEditors(
+        '{{ event.timezone }}',
+        '{{ LANGUAGE_CODE }}',
+        '{{ event.start | timezone:event.timezone | date:"Y-m-d H:i:s" }}',
+        '{{ event.end | timezone:event.timezone | date:"Y-m-d H:i:s" }}'
+      );
+    });
+  </script>
+{% endblock %}
+
+{% block breadcrumbs %}
+  {% include "AKPreference/poll_breadcrumbs.html" %}
+  <li class="breadcrumb-item active">{% trans "AK Preferences" %}</li>
+{% endblock %}
+
+{% block content %}
+  {% include "messages.html" %}
+
+  {% block headline %}
+    <h2>{% trans 'AK Preferences' %}</h2>
+  {% endblock %}
+  <form method="POST" class="post-form">{% csrf_token %}
+    {% block form_contents %}
+      {% bootstrap_form participant_form %}
+      <section>
+        <h3>{% trans "Your preferences" %}</h3>
+
+        <p>{% trans "Please enter your preferences." %}</p>
+
+        {{ formset.management_form }}
+
+        <div class="container radio-flex">
+          {% for innerform in formset %}
+            {% bootstrap_form_errors innerform type='non_fields' %}
+
+            {% for field in innerform.hidden_fields %}
+              {{ field }}
+            {% endfor %}
+
+            <div class="container radio-group">
+              <div class="container radio-info">
+                <h4>{{ innerform.preference.label }}
+                  {% if innerform.ak_obj.reso %}
+                    <span class="badge bg-dark rounded-pill"
+                      title="{% trans 'Intends to submit a resolution' %}">{% fa6_icon "scroll" 'fas' %}</span>
+                  {% endif %}
+                </h4>
+                <details>
+                  <summary>{% trans "Description" %}</summary>
+
+                  <p>{{ innerform.ak_obj.description }}</p>
+
+                  {% if innerform.ak_obj.owners_list %}
+                    <p>{% trans "Responsible" %}: {{ innerform.ak_obj.owners_list }}</p>
+                  {% endif %}
+                  {% if innerform.ak_obj.reso %}
+                    <!-- TODO: reso as an icon -->
+                    <p><i>{% trans "Intends to submit a resolution" %}.</i></p>
+                  {% endif %}
+                </details>
+              </div>
+              {% bootstrap_field innerform.preference show_label=False show_help=False field_class="pref-cls" %}
+            </div>
+          {% endfor %}
+        </div>
+      </section>
+    {% endblock %}
+    <button type="submit" class="save btn btn-primary float-end">
+      {% fa6_icon "check" 'fas' %} {% trans "Submit" %}
+    </button>
+
+    <button type="reset" class="btn btn-danger">
+      {% fa6_icon "undo-alt" 'fas' %} {% trans "Reset Form" %}
+    </button>
+
+    <a href="{% url 'dashboard:dashboard_event' slug=event.slug %}" class="btn btn-secondary">
+      {% fa6_icon "times" 'fas' %} {% trans "Cancel" %}
+    </a>
+  </form>
+{% endblock %}
+
+{% block bottom_script %}
+  <script src="{% static 'common/vendor/chosen-js/chosen.jquery.js' %}"></script>
+  <script>
+    $(function () {
+      $('.chosen-select').chosen();
+    });
+  </script>
+{% endblock %}

AKPreference/templates/AKPreference/poll_base.html

+{% extends "base.html" %}
+
+{% load fontawesome_6 %}
+{% load i18n %}
+
+{% block breadcrumbs %}
+    {% include "AKPreference/poll_breadcrumbs.html" %}
+{% endblock %}
+
+{% block footer_custom %}
+    {% if event.contact_email %}
+        <h4>
+            <a href="mailto:{{ event.contact_email }}">{% fa6_icon "envelope" 'fas' %} {% trans "Write to organizers of this event for questions and comments" %}</a>
+        </h4>
+    {% endif %}
+{% endblock %}

AKPreference/templates/AKPreference/poll_breadcrumbs.html

+{% load tags_AKModel %}
+
+<li class="breadcrumb-item">
+    {% if 'AKDashboard'|check_app_installed %}
+        <a href="{% url 'dashboard:dashboard' %}">AKPlanning</a>
+    {% else %}
+        AKPlanning
+    {% endif %}
+</li>
+<li class="breadcrumb-item">
+    {% if 'AKDashboard'|check_app_installed %}
+        <a href="{% url 'dashboard:dashboard_event' slug=event.slug %}">{{ event }}</a>
+    {% else %}
+        {{ event }}
+    {% endif %}
+</li>

AKPreference/templates/AKPreference/poll_not_configured.html

+{% extends 'AKPreference/poll_base.html' %}
+
+{% load i18n %}
+{% load fontawesome_6 %}
+{% load static %}
+
+{% block title %}{% trans "AKs" %}: {{ event.name }} - {% trans "AK Preference Poll" %}{% endblock %}
+
+{% block breadcrumbs %}
+    {% include "AKPreference/poll_breadcrumbs.html" %}
+    <li class="breadcrumb-item active">{% trans "AK Preference Poll" %}</li>
+{% endblock %}
+
+{% block content %}
+    <h1>{{ event.name }}</h1>
+
+    {% include "messages.html" %}
+
+    <div class="alert alert-warning" style="margin-top:20px;margin-bottom: 20px;">
+            {% trans "System is not yet configured for AK preference polling. Please try again later." %}
+        </div>
+{% endblock %}

AKPreference/tests.py

+from django.urls import reverse
+from django.test import TestCase
+
+from AKModel.models import Event
+from AKModel.tests.test_views import BasicViewTests
+
+class PollViewTests(BasicViewTests, TestCase):
+    """
+    Tests for AKPreference Poll
+    """
+    fixtures = ['model.json']
+    APP_NAME = 'poll'
+
+    def test_poll_redirect(self):
+        """
+        Test: Make sure that user is redirected from poll to dashboard when poll is hidden
+        """
+        event = Event.objects.get(slug='kif42')
+        _, url_poll = self._name_and_url(('poll', {'event_slug': event.slug}))
+        url_dashboard = reverse("dashboard:dashboard_event", kwargs={"slug": event.slug})
+
+        event.poll_hidden = True
+        event.save()
+
+        self.client.logout()
+        response = self.client.get(url_poll)
+
+        self.assertRedirects(response, url_dashboard,
+                             msg_prefix=f"Redirect away from poll not working ({url_poll} -> {url_dashboard})")
+
+        self.client.force_login(self.staff_user)
+        response = self.client.get(url_poll)
+
+        self.assertEqual(
+            response.status_code,
+            200,
+            msg=f"{url_poll} broken",
+        )
+
+        self.assertTemplateUsed(response, "AKPreference/poll.html", msg_prefix="Poll is not visible for staff user")

AKPreference/urls.py

+from django.urls import include, path
+
+from . import views
+
+app_name = "poll"
+
+urlpatterns = [
+    path(
+        "<slug:event_slug>/poll/",
+        include(
+            [
+                path("", views.PreferencePollCreateView.as_view(), name="poll"),
+            ]
+        ),
+    ),
+]

AKPreference/views.py

+import json
+
+from django import forms
+from django.contrib import messages
+from django.contrib.messages.views import SuccessMessageMixin
+from django.shortcuts import redirect
+from django.urls import reverse_lazy
+from django.utils.translation import gettext_lazy as _
+from django.views.generic import FormView
+
+from AKModel.availability.models import Availability
+from AKModel.availability.serializers import AvailabilityFormSerializer
+from AKModel.metaviews.admin import EventSlugMixin
+from AKModel.models import AK
+from AKPreference.models import AKPreference
+
+from .forms import EventParticipantForm
+
+
+class PreferencePollCreateView(EventSlugMixin, SuccessMessageMixin, FormView):
+    """
+    View: Show a form to register the AK preference of a participant.
+
+    The form creates the `EventParticipant` instance as well as the
+    AKPreferences for each AK of the event.
+
+    For the creation of the event participant, a `EventParticipantForm` is used.
+    For the preferences, a ModelFormset is created.
+    """
+
+    form_class = forms.Form
+    model = AKPreference
+    form_class = forms.modelform_factory(
+        model=AKPreference, fields=["preference", "ak", "event"]
+    )
+    template_name = "AKPreference/poll.html"
+    success_message = _("AK preferences were registered successfully")
+
+    def _create_modelformset(self):
+        return forms.modelformset_factory(
+            model=AKPreference,
+            fields=["preference", "ak", "event"],
+            widgets={
+                "ak": forms.HiddenInput,
+                "event": forms.HiddenInput,
+                "preference": forms.RadioSelect,
+            },
+            extra=0,
+        )
+
+    def get(self, request, *args, **kwargs):
+        s = super().get(request, *args, **kwargs)
+        # Don't show preference form when event is not active or poll is hidden -> redirect to dashboard
+        if not self.event.active or (self.event.poll_hidden and not request.user.is_staff):
+            return redirect(self.get_success_url())
+        return s
+
+    def get_success_url(self):
+        return reverse_lazy(
+            "dashboard:dashboard_event", kwargs={"slug": self.event.slug}
+        )
+
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        ak_set = (
+            AK.objects.filter(event=self.event)
+            .order_by()
+            .all()
+            .prefetch_related('owners')
+        )
+        initial_lst = [
+            {"ak": ak, "event": self.event} for ak in ak_set
+        ]
+
+        context["formset"] = self._create_modelformset()(
+            queryset=AKPreference.objects.none(),
+            initial=initial_lst,
+        )
+        context["formset"].extra = len(initial_lst)
+
+        for form, init in zip(context["formset"], initial_lst, strict=True):
+            form.fields["preference"].label = init["ak"].name
+            form.fields["preference"].help_text = (
+                "Description: " + init["ak"].description
+            )
+            form.ak_obj = init["ak"]
+
+        availabilities_serialization = AvailabilityFormSerializer(
+            (
+                [Availability.with_event_length(event=self.event)],
+                self.event,
+            )
+        )
+
+        context["participant_form"] = EventParticipantForm(
+            initial={
+                "event": self.event,
+                "availabilities": json.dumps(availabilities_serialization.data),
+            }
+        )
+        return context
+
+    def post(self, request, *args, **kwargs):
+        self._load_event()
+        model_formset_cls = self._create_modelformset()
+        formset = model_formset_cls(request.POST)
+        participant_form = EventParticipantForm(
+            data=request.POST, initial={"event": self.event}
+        )
+        if formset.is_valid() and participant_form.is_valid():
+            return self.form_valid(form=(formset, participant_form))
+        return self.form_invalid(form=(formset, participant_form))
+
+    def form_valid(self, form):
+        try:
+            formset, participant_form = form
+            participant = participant_form.save()
+            instances = formset.save(commit=False)
+            for instance in instances:
+                instance.participant = participant
+                instance.save()
+            success_message = self.get_success_message(participant_form.cleaned_data)
+            if success_message:
+                messages.success(self.request, success_message)
+        except:
+            messages.error(
+                self.request,
+                _(
+                    "Something went wrong. Your preferences were not saved. "
+                    "Please try again or contact the organizers."
+                ),
+            )
+            return self.form_invalid(form=form)
+        return redirect(self.get_success_url())