AKPlanning/settings_production.py

@@ -35,4 +35,8 @@ DATABASES = {
     }
 }
 
+### EMAILS ###
+SEND_MAILS = True
+EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
+
 # TODO: caching

AKPlanning/urls.py

-"""AKPlanning URL Configuration
+"""
+AKPlanning URL Configuration
 
 The `urlpatterns` list routes URLs to views. For more information please see:
     https://docs.djangoproject.com/en/2.2/topics/http/urls/
@@ -13,13 +14,15 @@ Including another URLconf
     1. Import the include() function: from django.urls import include, path
     2. Add a URL to urlpatterns:  path('blog/', include('blog.urls'))
 """
+
+import debug_toolbar
 from django.apps import apps
 from django.contrib import admin
-from django.urls import path, include
-import debug_toolbar
+from django.urls import path, include, re_path
 
 urlpatterns = [
     path('admin/', admin.site.urls),
+    re_path(r'^docs/', include('docs.urls')),
     path('accounts/', include('django.contrib.auth.urls')),
     path('accounts/', include('registration.backends.simple.urls')),
     path('', include('AKModel.urls', namespace='model')),
@@ -34,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())

AKScheduling/admin.py

-# Register your models here.

AKScheduling/api.py

@@ -7,48 +7,72 @@ from django.views.generic import ListView
 from rest_framework import viewsets, mixins, serializers, permissions
 
 from AKModel.availability.models import Availability
-from AKModel.models import Room, AKSlot, ConstraintViolation
-from AKModel.views import EventSlugMixin
+from AKModel.models import Room, AKSlot, ConstraintViolation, DefaultSlot
+from AKModel.metaviews.admin import EventSlugMixin
 
 
 class ResourceSerializer(serializers.ModelSerializer):
+    """
+    REST Framework Serializer for Rooms to produce format required for fullcalendar resources
+    """
     class Meta:
         model = Room
         fields = ['id', 'title']
 
     title = serializers.SerializerMethodField('transform_title')
 
-    def transform_title(self, obj):
+    @staticmethod
+    def transform_title(obj):
+        """
+        Adapt title, add capacity information if room has a restriction (capacity is not -1)
+        """
         if obj.capacity > 0:
             return f"{obj.title} [{obj.capacity}]"
         return obj.title
 
 
-class ResourcesViewSet(EventSlugMixin, mixins.RetrieveModelMixin, mixins.ListModelMixin, viewsets.GenericViewSet):
-    permission_classes = (permissions.DjangoModelPermissionsOrAnonReadOnly,)
+class ResourcesViewSet(EventSlugMixin, mixins.ListModelMixin, viewsets.GenericViewSet):
+    """
+    API View: Rooms (resources to schedule for in fullcalendar)
+
+    Read-only, adaption to fullcalendar format through :class:`ResourceSerializer`
+    """
+    permission_classes = (permissions.DjangoModelPermissions,)
     serializer_class = ResourceSerializer
 
     def get_queryset(self):
-        return Room.objects.filter(event=self.event)
+        return Room.objects.filter(event=self.event).order_by('location', 'name')
 
 
 class EventsView(LoginRequiredMixin, EventSlugMixin, ListView):
+    """
+    API View: Slots (events to schedule in fullcalendar)
+
+    Read-only, JSON formatted response is created manually since it requires a bunch of "custom" fields that have
+    different names compared to the normal model or are not present at all and need to be computed to create the
+    required format for fullcalendar.
+    """
     model = AKSlot
 
     def get_queryset(self):
-        return super().get_queryset().filter(event=self.event, room__isnull=False)
+        return super().get_queryset().select_related('ak').filter(
+            event=self.event, room__isnull=False, start__isnull=False
+        )
 
     def render_to_response(self, context, **response_kwargs):
         return JsonResponse(
             [{
                 "slotID": slot.pk,
-                "title": f'{slot.ak.short_name}: \n{slot.ak.owners_list}',
+                "title": f'{slot.ak.short_name}:\n{slot.ak.owners_list}',
                 "description": slot.ak.details,
                 "resourceId": slot.room.id,
                 "start": timezone.localtime(slot.start, self.event.timezone).strftime("%Y-%m-%d %H:%M:%S"),
                 "end": timezone.localtime(slot.end, self.event.timezone).strftime("%Y-%m-%d %H:%M:%S"),
                 "backgroundColor": slot.ak.category.color,
-                "borderColor": "#2c3e50" if slot.fixed else '#e74c3c' if slot.constraintviolation_set.count() > 0 else slot.ak.category.color,
+                "borderColor":
+                    "#2c3e50" if slot.fixed
+                    else '#e74c3c' if slot.constraintviolation_set.count() > 0
+                    else slot.ak.category.color,
                 "constraint": 'roomAvailable',
                 "editable": not slot.fixed,
                 'url': str(reverse('admin:AKModel_akslot_change', args=[slot.pk])),
@@ -59,6 +83,13 @@ class EventsView(LoginRequiredMixin, EventSlugMixin, ListView):
 
 
 class RoomAvailabilitiesView(LoginRequiredMixin, EventSlugMixin, ListView):
+    """
+    API view: Availabilities of rooms
+
+    Read-only, JSON formatted response is created manually since it requires a bunch of "custom" fields that have
+    different names compared to the normal model or are not present at all and need to be computed to create the
+    required format for fullcalendar.
+    """
     model = Availability
     context_object_name = "availabilities"
 
@@ -80,7 +111,41 @@ class RoomAvailabilitiesView(LoginRequiredMixin, EventSlugMixin, ListView):
         )
 
 
+class DefaultSlotsView(LoginRequiredMixin, EventSlugMixin, ListView):
+    """
+    API view: default slots
+
+    Read-only, JSON formatted response is created manually since it requires a bunch of "custom" fields that have
+    different names compared to the normal model or are not present at all and need to be computed to create the
+    required format for fullcalendar.
+    """
+    model = DefaultSlot
+    context_object_name = "default_slots"
+
+    def get_queryset(self):
+        return super().get_queryset().filter(event=self.event)
+
+    def render_to_response(self, context, **response_kwargs):
+        all_room_ids = [r.pk for r in self.event.room_set.all()]
+        return JsonResponse(
+            [{
+                "title": "",
+                "resourceIds": all_room_ids,
+                "start": timezone.localtime(a.start, self.event.timezone).strftime("%Y-%m-%d %H:%M:%S"),
+                "end": timezone.localtime(a.end, self.event.timezone).strftime("%Y-%m-%d %H:%M:%S"),
+                "display": 'background',
+                "groupId": 'defaultSlot',
+                "backgroundColor": '#69b6d4'
+            } for a in context["default_slots"]],
+            safe=False,
+            **response_kwargs
+        )
+
+
 class EventSerializer(serializers.ModelSerializer):
+    """
+    REST framework serializer to adapt between AKSlot model and the event format of fullcalendar
+    """
     class Meta:
         model = AKSlot
         fields = ['id', 'start', 'end', 'roomId']
@@ -90,17 +155,31 @@ class EventSerializer(serializers.ModelSerializer):
     roomId = serializers.IntegerField(source='room.pk')
 
     def update(self, instance, validated_data):
+        # Ignore timezone of input (treat it as timezone-less) and set the event timezone
+        # By working like this, the client does not need to know about timezones, since every timestamp it deals with
+        # has the timezone offsets already applied
         start = timezone.make_aware(timezone.make_naive(validated_data.get('start')), instance.event.timezone)
         end = timezone.make_aware(timezone.make_naive(validated_data.get('end')), instance.event.timezone)
         instance.start = start
-        instance.room = get_object_or_404(Room, pk=validated_data.get('room')["pk"])
+        # Also, adapt from start & end format of fullcalendar to our start & duration model
         diff = end - start
         instance.duration = round(diff.days * 24 + (diff.seconds / 3600), 2)
+
+        # Updated room if needed (pk changed -- otherwise, no need for an additional database lookup)
+        new_room_id = validated_data.get('room')["pk"]
+        if instance.room is None or instance.room.pk != new_room_id:
+            instance.room = get_object_or_404(Room, pk=new_room_id)
+
         instance.save()
         return instance
 
 
-class EventsViewSet(EventSlugMixin, viewsets.ModelViewSet):
+class EventsViewSet(EventSlugMixin, mixins.UpdateModelMixin, viewsets.GenericViewSet):
+    """
+    API view: Update scheduling of a slot (event in fullcalendar format)
+
+    Write-only (will however reply with written values to PUT request)
+    """
     permission_classes = (permissions.DjangoModelPermissions,)
     serializer_class = EventSerializer
 
@@ -112,17 +191,26 @@ class EventsViewSet(EventSlugMixin, viewsets.ModelViewSet):
 
 
 class ConstraintViolationSerializer(serializers.ModelSerializer):
+    """
+    REST Framework Serializer for constraint violations
+    """
     class Meta:
         model = ConstraintViolation
-        fields = ['pk', 'type_display', 'aks', 'ak_slots', 'ak_owner', 'room', 'requirement', 'category', 'comment', 'timestamp_display', 'manually_resolved', 'level_display', 'details']
+        fields = ['pk', 'type_display', 'aks', 'ak_slots', 'ak_owner', 'room', 'requirement', 'category', 'comment',
+                  'timestamp_display', 'manually_resolved', 'level_display', 'details', 'edit_url']
 
 
-class ConstraintViolationsViewSet(EventSlugMixin, viewsets.ModelViewSet):
+class ConstraintViolationsViewSet(EventSlugMixin, mixins.ListModelMixin, viewsets.GenericViewSet):
+    """
+    API View: Constraint Violations of an event
+
+    Read-only, fields and model selected in :class:`ConstraintViolationSerializer`
+    """
     permission_classes = (permissions.DjangoModelPermissions,)
     serializer_class = ConstraintViolationSerializer
 
-    def get_object(self):
-        return get_object_or_404(ConstraintViolation, pk=self.kwargs["pk"])
-
     def get_queryset(self):
-        return ConstraintViolation.objects.filter(event=self.event)
+        # Optimize query to reduce database load
+        return (ConstraintViolation.objects.select_related('event', 'room')
+                .prefetch_related('aks', 'ak_slots', 'ak_owner', 'requirement', 'category')
+                .filter(event=self.event).order_by('manually_resolved', '-type', '-timestamp'))