.docker/extra_requirements.txt

-uwsgi==2.0.25.1
+uwsgi==2.0.29

.gitlab-ci.yml

-image: python:3.9
+image: python:3.11
 
 services:
   - mysql
@@ -26,10 +26,9 @@ cache:
     - pip install pylint-gitlab pylint-django
     - mysql --version
 
-check:
+migrations:
   extends: .before_script_template
   script:
-    - ./Utils/check.sh --all
     - source venv/bin/activate
     - ./manage.py makemigrations --dry-run --check
 
@@ -38,7 +37,7 @@ test:
   script:
     - source venv/bin/activate
     - echo "GRANT ALL on *.* to '${MYSQL_USER}';"| mysql -u root --password="${MYSQL_ROOT_PASSWORD}" -h mysql
-    - pip install pytest-cov unittest-xml-reporting
+    - pip install pytest-cov
     - coverage run --source='.' manage.py test --settings AKPlanning.settings_ci
   after_script:
     - source venv/bin/activate

AKDashboard/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-08-16 16:30+0200\n"
+"POT-Creation-Date: 2025-01-01 17:28+0100\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"
@@ -61,17 +61,22 @@ msgstr "Veranstaltung"
 msgid "Event this button belongs to"
 msgstr "Veranstaltung, zu der dieser Button gehört"
 
-#: AKDashboard/templates/AKDashboard/dashboard.html:17
+#: AKDashboard/templates/AKDashboard/dashboard.html:18
 #: AKDashboard/templates/AKDashboard/dashboard_event.html:29
+#: AKDashboard/templates/AKDashboard/dashboard_row_old_event.html:53
 msgid "Write to organizers of this event for questions and comments"
 msgstr ""
 "Kontaktiere die Organisator*innen des Events bei Fragen oder Kommentaren"
 
 #: AKDashboard/templates/AKDashboard/dashboard.html:24
+msgid "Old events"
+msgstr "Frühere Veranstaltungen"
+
+#: AKDashboard/templates/AKDashboard/dashboard.html:34
 msgid "Currently, there are no Events!"
 msgstr "Aktuell gibt es keine Events!"
 
-#: AKDashboard/templates/AKDashboard/dashboard.html:27
+#: AKDashboard/templates/AKDashboard/dashboard.html:37
 msgid "Please contact an administrator if you want to use AKPlanning."
 msgstr ""
 "Bitte kontaktiere eine*n Administrator*in, falls du AKPlanning verwenden "
@@ -81,46 +86,49 @@ msgstr ""
 msgid "Recent"
 msgstr "Kürzlich"
 
-#: AKDashboard/templates/AKDashboard/dashboard_row.html:12
+#: AKDashboard/templates/AKDashboard/dashboard_row.html:18
+#: AKDashboard/templates/AKDashboard/dashboard_row_old_event.html:20
 msgid "AK List"
 msgstr "AK-Liste"
 
-#: AKDashboard/templates/AKDashboard/dashboard_row.html:23
+#: AKDashboard/templates/AKDashboard/dashboard_row.html:29
 msgid "Current AKs"
 msgstr "Aktuelle AKs"
 
-#: AKDashboard/templates/AKDashboard/dashboard_row.html:30
+#: AKDashboard/templates/AKDashboard/dashboard_row.html:36
 msgid "AK Wall"
 msgstr "AK-Wall"
 
-#: AKDashboard/templates/AKDashboard/dashboard_row.html:38
+#: AKDashboard/templates/AKDashboard/dashboard_row.html:44
+#: AKDashboard/templates/AKDashboard/dashboard_row_old_event.html:30
 msgid "Schedule"
 msgstr "AK-Plan"
 
-#: AKDashboard/templates/AKDashboard/dashboard_row.html:49
+#: AKDashboard/templates/AKDashboard/dashboard_row.html:55
 msgid "AK Submission"
 msgstr "AK-Einreichung"
 
-#: AKDashboard/templates/AKDashboard/dashboard_row.html:57
+#: AKDashboard/templates/AKDashboard/dashboard_row.html:63
+#: AKDashboard/templates/AKDashboard/dashboard_row_old_event.html:39
 msgid "AK History"
 msgstr "AK-Verlauf"
 
-#: AKDashboard/views.py:59
+#: AKDashboard/views.py:69
 #, python-format
 msgid "New AK: %(ak)s."
 msgstr "Neuer AK: %(ak)s."
 
-#: AKDashboard/views.py:62
+#: AKDashboard/views.py:72
 #, python-format
 msgid "AK \"%(ak)s\" edited."
 msgstr "AK \"%(ak)s\" bearbeitet."
 
-#: AKDashboard/views.py:65
+#: AKDashboard/views.py:75
 #, python-format
 msgid "AK \"%(ak)s\" deleted."
 msgstr "AK \"%(ak)s\" gelöscht."
 
-#: AKDashboard/views.py:80
+#: AKDashboard/views.py:90
 #, python-format
 msgid "AK \"%(ak)s\" (re-)scheduled."
 msgstr "AK \"%(ak)s\" (um-)geplant."

AKDashboard/static/AKDashboard/style.css

@@ -2,6 +2,10 @@
     margin-bottom: 5em;
 }
 
+.dashboard-row-small {
+    margin-bottom: 3em;
+}
+
 .dashboard-row > .row {
     margin-left: 0;
     padding-bottom: 1em;

AKDashboard/templates/AKDashboard/dashboard.html

@@ -9,16 +9,26 @@
 {% endblock %}
 
 {% block content %}
-    {% for event in events %}
-        <div class="dashboard-row">
-            {% include "AKDashboard/dashboard_row.html" %}
-            {% if event.contact_email %}
-                <p>
-                    <a href="mailto:{{ event.contact_email }}">{% fa6_icon "envelope" "fas" %} {% trans "Write to organizers of this event for questions and comments" %}</a>
-                </p>
-            {% endif %}
-        </div>
-    {% empty %}
+    {% if total_event_count > 0 %}
+        {% for event in active_and_current_events %}
+            <div class="dashboard-row">
+                {% include "AKDashboard/dashboard_row.html" %}
+                {% if event.contact_email %}
+                    <p>
+                        <a href="mailto:{{ event.contact_email }}">{% fa6_icon "envelope" "fas" %} {% trans "Write to organizers of this event for questions and comments" %}</a>
+                    </p>
+                {% endif %}
+            </div>
+        {% endfor %}
+        {% if old_event_count > 0 %}
+            <h2 class="mb-3">{% trans "Old events" %}</h2>
+            {% for event in old_events %}
+                <div class="dashboard-row-small">
+                    {% include "AKDashboard/dashboard_row_old_event.html" %}
+                </div>
+            {% endfor %}
+        {% endif %}
+    {% else %}
         <div class="jumbotron">
             <h2 class="display-4">
                 {% trans 'Currently, there are no Events!' %}
@@ -27,5 +37,5 @@
                 {% trans 'Please contact an administrator if you want to use AKPlanning.' %}
             </p>
         </div>
-    {% endfor %}
+    {% endif %}
 {% endblock %}

AKDashboard/templates/AKDashboard/dashboard_row.html

@@ -3,6 +3,12 @@
 {% load fontawesome_6 %}
 
 <h2><a href="{% url 'dashboard:dashboard_event' slug=event.slug %}">{{ event.name }}</a></h2>
+<h4 class="text-muted">
+    {% if event.place %}
+        <b>{{ event.place }} &middot;</b>
+    {% endif %}
+    {{ event | event_month_year }}
+</h4>
 <div class="mt-2">
     {% if 'AKSubmission'|check_app_installed %}
         <a class="dashboard-box btn btn-primary"

AKDashboard/templates/AKDashboard/dashboard_row_old_event.html

+{% load i18n %}
+{% load tags_AKModel %}
+{% load fontawesome_6 %}
+
+<h3><a href="{% url 'dashboard:dashboard_event' slug=event.slug %}">{{ event.name }}</a>
+    <span class="text-muted">
+        &middot;
+        {% if event.place %}
+            {{ event.place }} &middot;
+        {% endif %}
+        {{ event | event_month_year }}
+    </span>
+</h3>
+<div class="mt-2">
+    {% if 'AKSubmission'|check_app_installed %}
+        <a class="btn btn-primary"
+           href="{% url 'submit:ak_list' event_slug=event.slug %}">
+            <div class="col-sm-12 col-md-3 col-lg-2 dashboard-button">
+                <span class="fa fa-list-ul"></span>
+                <span class='text'>{% trans 'AK List' %}</span>
+            </div>
+        </a>
+    {% endif %}
+    {% if 'AKPlan'|check_app_installed %}
+        {% if not event.plan_hidden or user.is_staff %}
+            <a class="btn btn-primary"
+               href="{% url 'plan:plan_overview' event_slug=event.slug %}">
+                <div class="col-sm-12 col-md-3 col-lg-2 dashboard-button">
+                    <span class="fa fa-calendar-alt"></span>
+                    <span class='text'>{% trans 'Schedule' %}</span>
+                </div>
+            </a>
+        {% endif %}
+    {% endif %}
+    <a class="btn btn-primary"
+       href="{% url 'dashboard:dashboard_event' slug=event.slug %}#history">
+        <div class="col-sm-12 col-md-3 col-lg-2 dashboard-button">
+            <span class="fa fa-history"></span>
+            <span class='text'>{% trans 'AK History' %}</span>
+        </div>
+    </a>
+    {% for button in event.dashboardbutton_set.all %}
+        <a class="btn btn-{{ button.get_color_display }}"
+           href="{{ button.url }}">
+            <div class="col-sm-12 col-md-3 col-lg-2 dashboard-button">
+                {% if button.icon %}<span class="fa">{{ button.icon.as_html }}</span>{% endif %}
+                <span class='text'>{{ button.text }}</span>
+            </div>
+        </a>
+    {% endfor %}
+    <a class="btn btn-info"
+       href=mailto:{{ event.contact_email }}"
+       title="{% trans 'Write to organizers of this event for questions and comments' %}">
+            {% fa6_icon "envelope" "fas" %}
+    </a>
+</div>

AKDashboard/tests.py

 import zoneinfo
+
 from django.apps import apps
-from django.test import TestCase, override_settings
+from django.test import override_settings, TestCase
 from django.urls import reverse
 from django.utils.timezone import now
 
 from AKDashboard.models import DashboardButton
-from AKModel.models import Event, AK, AKCategory
-from AKModel.tests import BasicViewTests
+from AKModel.models import AK, AKCategory, Event
+from AKModel.tests.test_views import BasicViewTests
 
 
 class DashboardTests(TestCase):
     """
     Specific Dashboard Tests
     """
+
     @classmethod
     def setUpTestData(cls):
         """
@@ -20,17 +22,17 @@ class DashboardTests(TestCase):
         """
         super().setUpTestData()
         cls.event = Event.objects.create(
-            name="Dashboard Test Event",
-            slug="dashboardtest",
-            timezone=zoneinfo.ZoneInfo("Europe/Berlin"),
-            start=now(),
-            end=now(),
-            active=True,
-            plan_hidden=False,
+                name="Dashboard Test Event",
+                slug="dashboardtest",
+                timezone=zoneinfo.ZoneInfo("Europe/Berlin"),
+                start=now(),
+                end=now(),
+                active=True,
+                plan_hidden=False,
         )
         cls.default_category = AKCategory.objects.create(
-            name="Test Category",
-            event=cls.event,
+                name="Test Category",
+                event=cls.event,
         )
 
     def test_dashboard_view(self):
@@ -62,12 +64,12 @@ class DashboardTests(TestCase):
 
         # History should be empty
         response = self.client.get(url)
-        self.assertQuerysetEqual(response.context["recent_changes"], [])
+        self.assertQuerySetEqual(response.context["recent_changes"], [])
 
         AK.objects.create(
-            name="Test AK",
-            category=self.default_category,
-            event=self.event,
+                name="Test AK",
+                category=self.default_category,
+                event=self.event,
         )
 
         # History should now contain one AK (Test AK)
@@ -90,7 +92,8 @@ class DashboardTests(TestCase):
         self.event.save()
         response = self.client.get(url_dashboard_index)
         self.assertEqual(response.status_code, 200)
-        self.assertFalse(self.event in response.context["events"])
+        self.assertFalse(self.event in response.context["active_and_current_events"])
+        self.assertFalse(self.event in response.context["old_events"])
         response = self.client.get(url_event_dashboard)
         self.assertEqual(response.status_code, 200)
         self.assertEqual(response.context["event"], self.event)
@@ -100,7 +103,7 @@ class DashboardTests(TestCase):
         self.event.save()
         response = self.client.get(url_dashboard_index)
         self.assertEqual(response.status_code, 200)
-        self.assertTrue(self.event in response.context["events"])
+        self.assertTrue(self.event in response.context["active_and_current_events"])
 
     def test_active(self):
         """
@@ -153,8 +156,8 @@ class DashboardTests(TestCase):
         self.assertNotContains(response, "Dashboard Button Test")
 
         DashboardButton.objects.create(
-            text="Dashboard Button Test",
-            event=self.event
+                text="Dashboard Button Test",
+                event=self.event
         )
 
         response = self.client.get(url_event_dashboard)

AKDashboard/views.py

@@ -22,7 +22,18 @@ class DashboardView(TemplateView):
 
     def get_context_data(self, **kwargs):
         context = super().get_context_data(**kwargs)
-        context['events'] = Event.objects.filter(public=True).prefetch_related('dashboardbutton_set')
+        # Load events and split between active and current/featured events and those that should show smaller below
+        context["active_and_current_events"] = []
+        context["old_events"] = []
+        events = Event.objects.filter(public=True).order_by("-active", "-pk").prefetch_related('dashboardbutton_set')
+        for event in events:
+            if event.active or len(context["active_and_current_events"]) < settings.DASHBOARD_MAX_FEATURED_EVENTS:
+                context["active_and_current_events"].append(event)
+            else:
+                context["old_events"].append(event)
+        context["active_event_count"] = len(context["active_and_current_events"])
+        context["old_event_count"] = len(context["old_events"])
+        context["total_event_count"] = context["active_event_count"] + context["old_event_count"]
         return context
 
 

AKModel/admin.py

@@ -2,6 +2,8 @@ from django import forms
 from django.apps import apps
 from django.contrib import admin, messages
 from django.contrib.admin import SimpleListFilter, RelatedFieldListFilter, action, display
+from django.contrib.auth.admin import UserAdmin as BaseUserAdmin
+from django.contrib.auth.models import User # pylint: disable=E5142
 from django.db.models import Count, F
 from django.http import HttpResponseRedirect
 from django.shortcuts import render, redirect
@@ -15,7 +17,7 @@ from simple_history.admin import SimpleHistoryAdmin
 from AKModel.availability.models import Availability
 from AKModel.forms import RoomFormWithAvailabilities
 from AKModel.models import Event, AKOwner, AKCategory, AKTrack, AKRequirement, AK, AKSlot, Room, AKOrgaMessage, \
-    ConstraintViolation, DefaultSlot
+    ConstraintViolation, DefaultSlot, AKType, EventParticipant, AKPreference
 from AKModel.urls import get_admin_urls_event_wizard, get_admin_urls_event
 from AKModel.views.ak import AKResetInterestView, AKResetInterestCounterView
 from AKModel.views.manage import CVMarkResolvedView, CVSetLevelViolationView, CVSetLevelWarningView
@@ -215,6 +217,18 @@ class AKRequirementAdmin(PrepopulateWithNextActiveEventMixin, admin.ModelAdmin):
     ordering = ['name']
 
 
+@admin.register(AKType)
+class AKTypeAdmin(PrepopulateWithNextActiveEventMixin, admin.ModelAdmin):
+    """
+    Admin interface for AKRequirements
+    """
+    model = AKType
+    list_display = ['name', 'event']
+    list_filter = ['event']
+    list_editable = []
+    ordering = ['name']
+
+
 class WishFilter(SimpleListFilter):
     """
     Re-usable filter for wishes
@@ -257,6 +271,7 @@ class AKAdminForm(forms.ModelForm):
             self.fields["requirements"].queryset = AKRequirement.objects.filter(event=self.instance.event)
             self.fields["conflicts"].queryset = AK.objects.filter(event=self.instance.event)
             self.fields["prerequisites"].queryset = AK.objects.filter(event=self.instance.event)
+            self.fields["types"].queryset = AKType.objects.filter(event=self.instance.event)
 
 
 @admin.register(AK)
@@ -555,3 +570,85 @@ class DefaultSlotAdmin(EventTimezoneFormMixin, admin.ModelAdmin):
     list_display = ['start_simplified', 'end_simplified', 'event']
     list_filter = ['event']
     form = DefaultSlotAdminForm
+
+
+@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,
+            'slot': 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["slot"].queryset = AKSlot.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', 'slot', 'event']
+    list_filter = ['event', 'slot', 'participant']
+    list_editable = []
+    ordering = ['participant', 'preference', 'slot']
+
+
+# Define a new User admin
+class UserAdmin(BaseUserAdmin):
+    """
+    Admin interface for Users
+    Enhances the built-in UserAdmin with additional actions to activate and deactivate users and a custom selection
+    of displayed properties in overview list
+    """
+    list_display = ["username", "email", "is_active", "is_staff", "is_superuser"]
+    actions = ['activate', 'deactivate']
+
+    @admin.action(description=_("Activate selected users"))
+    def activate(self, request, queryset):
+        """
+        Bulk activate users
+
+        :param request: HTTP request
+        :param queryset: queryset containing all users that should be activated
+        """
+        queryset.update(is_active=True)
+        self.message_user(request, _("The selected users have been activated."))
+
+    @admin.action(description=_("Deactivate selected users"))
+    def deactivate(self, request, queryset):
+        """
+        Bulk deactivate users
+
+        :param request: HTTP request
+        :param queryset: queryset containing all users that should be deactivated
+        """
+        queryset.update(is_active=False)
+        self.message_user(request, _("The selected users have been deactivated."))
+
+
+# Re-register UserAdmin
+admin.site.unregister(User)
+admin.site.register(User, UserAdmin)

AKModel/availability/forms.py

@@ -183,7 +183,7 @@ class AvailabilitiesFormMixin(forms.Form):
         for avail in availabilities:
             setattr(avail, reference_name, instance.id)
 
-    def _replace_availabilities(self, instance, availabilities: [Availability]):
+    def _replace_availabilities(self, instance, availabilities: list[Availability]):
         """
         Replace the existing list of availabilities belonging to an entity with a new, updated one
 

AKModel/availability/models.py

@@ -10,7 +10,7 @@ from django.db import models
 from django.utils.functional import cached_property
 from django.utils.translation import gettext_lazy as _
 
-from AKModel.models import Event, AKOwner, Room, AK, AKCategory
+from AKModel.models import Event, AKOwner, Room, AK, AKCategory, EventParticipant
 
 zero_time = datetime.time(0, 0)
 
@@ -24,6 +24,7 @@ zero_time = datetime.time(0, 0)
 # enable availabilities for AKs and AKCategories
 # add verbose names and help texts to model attributes
 # adapt or extemd documentation
+# add participants
 
 
 class Availability(models.Model):
@@ -79,20 +80,48 @@ class Availability(models.Model):
         verbose_name=_('AK Category'),
         help_text=_('AK Category whose availability this is'),
     )
+    participant = models.ForeignKey(
+        to=EventParticipant,
+        related_name='availabilities',
+        on_delete=models.CASCADE,
+        null=True,
+        blank=True,
+        verbose_name=_('Participant'),
+        help_text=_('Participant whose availability this is'),
+    )
     start = models.DateTimeField()
     end = models.DateTimeField()
 
     def __str__(self) -> str:
         person = self.person.name if self.person else None
+        participant = self.participant.name if self.participant else None
         room = getattr(self.room, 'name', None)
         event = getattr(getattr(self, 'event', None), 'name', None)
         ak = getattr(self.ak, 'name', None)
         ak_category = getattr(self.ak_category, 'name', None)
-        return f'Availability(event={event}, person={person}, room={room}, ak={ak}, ak category={ak_category})'
+        arg_list = [
+            f"event={event}",
+            f"person={person}",
+            f"room={room}",
+            f"ak={ak}",
+            f"ak category={ak_category}",
+            f"participant={participant}",
+        ]
+        return f'Availability({", ".join(arg_list)})'
 
     def __hash__(self):
         return hash(
-            (getattr(self, 'event', None), self.person, self.room, self.ak, self.ak_category, self.start, self.end))
+            (
+                getattr(self, 'event', None),
+                self.person,
+                self.room,
+                self.ak,
+                self.ak_category,
+                self.participant,
+                self.start,
+                self.end,
+            )
+        )
 
     def __eq__(self, other: 'Availability') -> bool:
         """Comparisons like ``availability1 == availability2``.
@@ -103,7 +132,7 @@ class Availability(models.Model):
         return all(
             (
                 getattr(self, attribute, None) == getattr(other, attribute, None)
-                for attribute in ['event', 'person', 'room', 'ak', 'ak_category', 'start', 'end']
+                for attribute in ['event', 'person', 'room', 'ak', 'ak_category', 'participant', 'start', 'end']
             )
         )
 
@@ -151,9 +180,12 @@ class Availability(models.Model):
         if not other.overlaps(self, strict=False):
             raise Exception('Only overlapping Availabilities can be merged.')
 
-        return Availability(
+        avail = Availability(
             start=min(self.start, other.start), end=max(self.end, other.end)
         )
+        if self.event == other.event:
+            avail.event = self.event
+        return avail
 
     def __or__(self, other: 'Availability') -> 'Availability':
         """Performs the merge operation: ``availability1 | availability2``"""
@@ -168,9 +200,12 @@ class Availability(models.Model):
         if not other.overlaps(self, False):
             raise Exception('Only overlapping Availabilities can be intersected.')
 
-        return Availability(
+        avail = Availability(
             start=max(self.start, other.start), end=min(self.end, other.end)
         )
+        if self.event == other.event:
+            avail.event = self.event
+        return avail
 
     def __and__(self, other: 'Availability') -> 'Availability':
         """Performs the intersect operation: ``availability1 &
@@ -247,7 +282,15 @@ class Availability(models.Model):
                 f'{self.end.astimezone(self.event.timezone).strftime("%a %H:%M")}')
 
     @classmethod
-    def with_event_length(cls, event, person=None, room=None, ak=None, ak_category=None):
+    def with_event_length(
+        cls,
+        event: Event,
+        person: AKOwner | None = None,
+        room: Room | None = None,
+        ak: AK | None = None,
+        ak_category: AKCategory | None = None,
+        participant: EventParticipant | None = None,
+    ) -> "Availability":
         """
         Create an availability covering exactly the time between event start and event end.
         Can e.g., be used to create default availabilities.
@@ -265,7 +308,31 @@ class Availability(models.Model):
         timeframe_end = event.end  # adapt to our event model
         timeframe_end = timeframe_end + datetime.timedelta(days=1)
         return Availability(start=timeframe_start, end=timeframe_end, event=event, person=person,
-                                    room=room, ak=ak, ak_category=ak_category)
+                                    room=room, ak=ak, ak_category=ak_category, participant=participant)
+
+    def is_covered(self, availabilities: List['Availability']):
+        """Check if list of availibilities cover this object.
+
+        :param availabilities: availabilities to check.
+        :return: whether the availabilities cover full event.
+        :rtype: bool
+        """
+        avail_union = Availability.union(availabilities)
+        return any(avail.contains(self) for avail in avail_union)
+
+    @classmethod
+    def is_event_covered(cls, event: Event, availabilities: List['Availability']) -> bool:
+        """Check if list of availibilities cover whole event.
+
+        :param event: event to check.
+        :param availabilities: availabilities to check.
+        :return: whether the availabilities cover full event.
+        :rtype: bool
+        """
+        # NOTE: Cannot use `Availability.with_event_length` as its end is the
+        #       event end + 1 day
+        full_event = Availability(event=event, start=event.start, end=event.end)
+        return full_event.is_covered(availabilities)
 
     class Meta:
         verbose_name = _('Availability')

AKModel/fixtures/model.json

@@ -93,7 +93,7 @@
     "model": "AKModel.akcategory",
     "pk": 1,
     "fields": {
-        "name": "Spa▀",
+        "name": "Spaß",
         "color": "275246",
         "description": "",
         "present_by_default": true,
@@ -115,7 +115,7 @@
     "model": "AKModel.akcategory",
     "pk": 3,
     "fields": {
-        "name": "Spa▀/Kultur",
+        "name": "Spaß/Kultur",
         "color": "333333",
         "description": "",
         "present_by_default": true,
@@ -193,6 +193,14 @@
         "event": 2
     }
 },
+{
+    "model": "AKModel.aktype",
+    "pk": 1,
+    "fields": {
+        "name": "Input",
+        "event": 2
+    }
+},
 {
     "model": "AKModel.historicalak",
     "pk": 1,
@@ -206,7 +214,6 @@
         "reso": false,
         "present": true,
         "notes": "",
-        "interest": -1,
         "category": 4,
         "track": null,
         "event": 2,
@@ -229,7 +236,6 @@
         "reso": false,
         "present": true,
         "notes": "",
-        "interest": -1,
         "category": 4,
         "track": null,
         "event": 2,
@@ -252,7 +258,6 @@
         "reso": false,
         "present": null,
         "notes": "",
-        "interest": -1,
         "category": 5,
         "track": null,
         "event": 2,
@@ -275,7 +280,6 @@
         "reso": false,
         "present": null,
         "notes": "",
-        "interest": -1,
         "category": 5,
         "track": null,
         "event": 2,
@@ -298,7 +302,6 @@
         "reso": false,
         "present": null,
         "notes": "We need to find a volunteer first...",
-        "interest": -1,
         "category": 3,
         "track": null,
         "event": 2,
@@ -321,7 +324,6 @@
         "reso": false,
         "present": null,
         "notes": "We need to find a volunteer first...",
-        "interest": -1,
         "category": 3,
         "track": null,
         "event": 2,
@@ -344,7 +346,6 @@
         "reso": false,
         "present": null,
         "notes": "",
-        "interest": -1,
         "category": 5,
         "track": 1,
         "event": 2,
@@ -436,6 +437,62 @@
         ]
     }
 },
+{
+    "model": "AKModel.ak",
+    "pk": 4,
+    "fields": {
+        "name": "Test AK fixed slots",
+        "short_name": "testfixed",
+        "description": "",
+        "link": "",
+        "protocol_link": "",
+        "category": 4,
+        "track": null,
+        "reso": false,
+        "present": true,
+        "notes": "",
+        "interest": -1,
+        "interest_counter": 0,
+        "include_in_export": false,
+        "event": 2,
+        "owners": [
+            1
+        ],
+        "requirements": [
+            3
+        ],
+        "conflicts": [],
+        "prerequisites": []
+    }
+},
+{
+    "model": "AKModel.ak",
+    "pk": 5,
+    "fields": {
+        "name": "Test AK Ernst",
+        "short_name": "testernst",
+        "description": "",
+        "link": "",
+        "protocol_link": "",
+        "category": 2,
+        "track": null,
+        "reso": false,
+        "present": true,
+        "notes": "",
+        "interest": -1,
+        "interest_counter": 0,
+        "include_in_export": false,
+        "event": 1,
+        "owners": [
+            3
+        ],
+        "requirements": [
+            2
+        ],
+        "conflicts": [],
+        "prerequisites": []
+    }
+},
 {
     "model": "AKModel.room",
     "pk": 1,
@@ -460,6 +517,19 @@
         "properties": []
     }
 },
+{
+    "model": "AKModel.room",
+    "pk": 3,
+    "fields": {
+        "name": "BBB Session 1",
+        "location": "",
+        "capacity": -1,
+        "event": 1,
+        "properties": [
+            2
+        ]
+    }
+},
 {
     "model": "AKModel.akslot",
     "pk": 1,
@@ -525,6 +595,58 @@
         "updated": "2022-12-02T12:23:11.856Z"
     }
 },
+{
+    "model": "AKModel.akslot",
+    "pk": 6,
+    "fields": {
+        "ak": 4,
+        "room": null,
+        "start": "2020-11-08T18:30:00Z",
+        "duration": "2.00",
+        "fixed": true,
+        "event": 2,
+        "updated": "2022-12-02T12:23:11.856Z"
+    }
+},
+{
+    "model": "AKModel.akslot",
+    "pk": 7,
+    "fields": {
+        "ak": 4,
+        "room": 2,
+        "start": null,
+        "duration": "2.00",
+        "fixed": true,
+        "event": 2,
+        "updated": "2022-12-02T12:23:11.856Z"
+    }
+},
+{
+    "model": "AKModel.akslot",
+    "pk": 8,
+    "fields": {
+        "ak": 4,
+        "room": 2,
+        "start": "2020-11-07T16:00:00Z",
+        "duration": "2.00",
+        "fixed": true,
+        "event": 2,
+        "updated": "2022-12-02T12:23:11.856Z"
+    }
+},
+{
+    "model": "AKModel.akslot",
+    "pk": 9,
+    "fields": {
+        "ak": 5,
+        "room": null,
+        "start": null,
+        "duration": "2.00",
+        "fixed": false,
+        "event": 1,
+        "updated": "2022-12-02T12:23:11.856Z"
+    }
+},
 {
     "model": "AKModel.constraintviolation",
     "pk": 1,
@@ -668,5 +790,71 @@
         "start": "2020-11-07T18:30:00Z",
         "end": "2020-11-07T21:30:00Z"
     }
+},
+{
+    "model": "AKModel.availability",
+    "pk": 7,
+    "fields": {
+        "event": 1,
+        "person": null,
+        "room": null,
+        "ak": 5,
+        "ak_category": null,
+        "start": "2020-10-01T17:41:22Z",
+        "end": "2020-10-04T17:41:30Z"
+    }
+},
+{
+    "model": "AKModel.availability",
+    "pk": 8,
+    "fields": {
+        "event": 1,
+        "person": null,
+        "room": 3,
+        "ak": null,
+        "ak_category": null,
+        "start": "2020-10-01T17:41:22Z",
+        "end": "2020-10-04T17:41:30Z"
+    }
+},
+{
+    "model": "AKModel.defaultslot",
+    "pk": 1,
+    "fields": {
+        "event": 2,
+        "start": "2020-11-07T08:00:00Z",
+        "end": "2020-11-07T12:00:00Z",
+        "primary_categories": [5]
+    }
+},
+{
+    "model": "AKModel.defaultslot",
+    "pk": 2,
+    "fields": {
+        "event": 2,
+        "start": "2020-11-07T14:00:00Z",
+        "end": "2020-11-07T17:00:00Z",
+        "primary_categories": [4]
+    }
+},
+{
+    "model": "AKModel.defaultslot",
+    "pk": 3,
+    "fields": {
+        "event": 2,
+        "start": "2020-11-08T08:00:00Z",
+        "end": "2020-11-08T19:00:00Z",
+        "primary_categories": [4, 5]
+    }
+},
+{
+    "model": "AKModel.defaultslot",
+    "pk": 4,
+    "fields": {
+        "event": 2,
+        "start": "2020-11-09T17:00:00Z",
+        "end": "2020-11-10T01:00:00Z",
+        "primary_categories": [4, 5, 3]
+    }
 }
 ]

AKModel/forms.py

@@ -4,13 +4,17 @@ Central and admin forms
 
 import csv
 import io
+import json
 
 from django import forms
+from django.core.exceptions import ValidationError
 from django.forms.utils import ErrorList
 from django.utils.translation import gettext_lazy as _
+from jsonschema.exceptions import best_match
 
 from AKModel.availability.forms import AvailabilitiesFormMixin
-from AKModel.models import Event, AKCategory, AKRequirement, Room
+from AKModel.models import Event, AKCategory, AKRequirement, Room, AKType
+from AKModel.utils import construct_schema_validator
 
 
 class DateTimeInput(forms.DateInput):
@@ -101,6 +105,13 @@ class NewEventWizardImportForm(forms.Form):
         required=False,
     )
 
+    import_types = forms.ModelMultipleChoiceField(
+        queryset=AKType.objects.all(),
+        widget=forms.CheckboxSelectMultiple,
+        label=_("Copy types"),
+        required=False,
+    )
+
     # pylint: disable=too-many-arguments
     def __init__(self, data=None, files=None, auto_id='id_%s', prefix=None, initial=None, error_class=ErrorList,
                  label_suffix=None, empty_permitted=False, field_order=None, use_required_attribute=None,
@@ -111,6 +122,8 @@ class NewEventWizardImportForm(forms.Form):
             event=self.initial["import_event"])
         self.fields["import_requirements"].queryset = self.fields["import_requirements"].queryset.filter(
             event=self.initial["import_event"])
+        self.fields["import_types"].queryset = self.fields["import_types"].queryset.filter(
+            event=self.initial["import_event"])
 
         # pylint: disable=import-outside-toplevel
         # Local imports used to prevent cyclic imports and to only import when AKDashboard is available
@@ -272,3 +285,88 @@ class RoomFormWithAvailabilities(AvailabilitiesFormMixin, RoomForm):
         # Filter possible values for m2m when event is specified
         if hasattr(self.instance, "event") and self.instance.event is not None:
             self.fields["properties"].queryset = AKRequirement.objects.filter(event=self.instance.event)
+
+
+class JSONScheduleImportForm(AdminIntermediateForm):
+    """Form to import an AK schedule from a json file."""
+    json_data = forms.CharField(
+        required=False,
+        widget=forms.Textarea,
+        label=_("JSON data"),
+        help_text=_("JSON data from the scheduling solver"),
+    )
+
+    json_file = forms.FileField(
+        required=False,
+        label=_("File with JSON data"),
+        help_text=_("File with JSON data from the scheduling solver"),
+    )
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.json_schema_validator = construct_schema_validator(
+            schema="solver-output.schema.json"
+        )
+
+    def _check_json_data(self, data: str):
+        """Validate `data` against our JSON schema.
+
+        :param data: The JSON string to validate using `self.json_schema_validator`.
+        :type data: str
+        :raises ValidationError: if the validation fails, with a description of the cause.
+        :return: The parsed JSON dict, if validation is successful.
+        """
+        try:
+            schedule = json.loads(data)
+        except json.JSONDecodeError as ex:
+            raise ValidationError(_("Cannot decode as JSON"), "invalid") from ex
+
+        error = best_match(self.json_schema_validator.iter_errors(schedule))
+        if error:
+            raise ValidationError(
+                _("Invalid JSON format: %(msg)s at %(error_path)s"),
+                "invalid",
+                params={
+                    "msg": error.message,
+                    "error_path": error.json_path
+                }
+            ) from error
+
+        return schedule
+
+    def clean(self):
+        """Extract and validate entered JSON data.
+
+        We allow entering of the schedule from two sources:
+        1. from an uploaded file
+        2. from a text field.
+
+        This function checks that data is entered from exactly one source.
+        If so, the entered JSON string is validated against our schema.
+        Any errors are reported at the corresponding form field.
+        """
+        cleaned_data = super().clean()
+        if cleaned_data.get("json_file") and cleaned_data.get("json_data"):
+            err = ValidationError(
+                _("Please enter data as a file OR via text, not both."), "invalid"
+            )
+            self.add_error("json_data", err)
+            self.add_error("json_file", err)
+        elif not (cleaned_data.get("json_file") or cleaned_data.get("json_data")):
+            err = ValidationError(
+                _("No data entered. Please enter data as a file or via text."), "invalid"
+            )
+            self.add_error("json_data", err)
+            self.add_error("json_file", err)
+        else:
+            source_field = "json_data"
+            data = cleaned_data.get(source_field)
+            if not data:
+                source_field = "json_file"
+                with cleaned_data.get(source_field).open() as ff:
+                    data = ff.read()
+            try:
+                cleaned_data["data"] = self._check_json_data(data)
+            except ValidationError as ex:
+                self.add_error(source_field, ex)
+        return cleaned_data

AKModel/migrations/0061_types.py

+# Generated by Django 4.2.13 on 2025-02-25 20:58
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('AKModel', '0060_orga_message_resolved'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='AKType',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(help_text='Name describing the type', max_length=128, verbose_name='Name')),
+                ('event', models.ForeignKey(help_text='Associated event', on_delete=django.db.models.deletion.CASCADE, to='AKModel.event', verbose_name='Event')),
+            ],
+            options={
+                'verbose_name': 'AK Type',
+                'verbose_name_plural': 'AK Types',
+                'ordering': ['name'],
+                'unique_together': {('event', 'name')},
+            },
+        ),
+        migrations.AddField(
+            model_name='ak',
+            name='types',
+            field=models.ManyToManyField(blank=True, help_text='This AK is', to='AKModel.aktype', verbose_name='Types'),
+        ),
+    ]

AKModel/migrations/0062_interest_no_history.py

+# Generated by Django 4.2.13 on 2025-02-26 22:35
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('AKModel', '0061_types'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='historicalak',
+            name='interest',
+        ),
+    ]

AKModel/migrations/0063_field_validators.py

+# Generated by Django 4.2.13 on 2025-03-03 19:59
+
+import django.core.validators
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('AKModel', '0062_interest_no_history'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='ak',
+            name='name',
+            field=models.CharField(help_text='Name of the AK', max_length=256, validators=[django.core.validators.RegexValidator(inverse_match=True, message='May not contain quotation marks', regex='[\'\\"´`]+'), django.core.validators.RegexValidator(message='Must contain at least one letter or digit', regex='[\\w\\s]+')], verbose_name='Name'),
+        ),
+        migrations.AlterField(
+            model_name='ak',
+            name='short_name',
+            field=models.CharField(blank=True, help_text='Name displayed in the schedule', max_length=64, validators=[django.core.validators.RegexValidator(inverse_match=True, message='May not contain quotation marks', regex='[\'\\"´`]+')], verbose_name='Short Name'),
+        ),
+        migrations.AlterField(
+            model_name='akowner',
+            name='name',
+            field=models.CharField(help_text='Name to identify an AK owner by', max_length=64, validators=[django.core.validators.RegexValidator(inverse_match=True, message='May not contain quotation marks', regex='[\'\\"´`]+'), django.core.validators.RegexValidator(message='Must contain at least one letter or digit', regex='[\\w\\s]+')], verbose_name='Nickname'),
+        ),
+        migrations.AlterField(
+            model_name='historicalak',
+            name='name',
+            field=models.CharField(help_text='Name of the AK', max_length=256, validators=[django.core.validators.RegexValidator(inverse_match=True, message='May not contain quotation marks', regex='[\'\\"´`]+'), django.core.validators.RegexValidator(message='Must contain at least one letter or digit', regex='[\\w\\s]+')], verbose_name='Name'),
+        ),
+        migrations.AlterField(
+            model_name='historicalak',
+            name='short_name',
+            field=models.CharField(blank=True, help_text='Name displayed in the schedule', max_length=64, validators=[django.core.validators.RegexValidator(inverse_match=True, message='May not contain quotation marks', regex='[\'\\"´`]+')], verbose_name='Short Name'),
+        ),
+    ]

AKModel/migrations/0064_event_export_slot.py

+# Generated by Django 5.1.6 on 2025-03-29 22:05
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("AKModel", "0063_field_validators"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="event",
+            name="export_slot",
+            field=models.DecimalField(
+                decimal_places=2,
+                default=1,
+                help_text="Slot duration in hours that is used in the timeslot discretization, when this event is exported for the solver.",
+                max_digits=4,
+                verbose_name="Export Slot Length",
+            ),
+        ),
+    ]

AKModel/migrations/0065_eventparticipant_akpreference_and_more.py

+# Generated by Django 4.2.13 on 2025-02-10 10:23
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("AKModel", "0064_event_export_slot"),
+    ]
+
+    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",
+                    ),
+                ),
+            ],
+            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, "Prefer"),
+                            (2, "Strong prefer"),
+                            (3, "Required"),
+                        ],
+                        default=0,
+                        help_text="Preference level for the AK",
+                        verbose_name="Preference",
+                    ),
+                ),
+                (
+                    "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="AKModel.eventparticipant",
+                        verbose_name="Participant",
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "AK Preference",
+                "verbose_name_plural": "AK Preferences",
+            },
+        ),
+        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="AKModel.eventparticipant",
+                verbose_name="Participant",
+            ),
+        ),
+    ]