AKModel/templates/admin/AKModel/event_wizard/import.html

@@ -8,11 +8,14 @@
 
 {% block title %}{% trans "New event wizard" %}: {{ wizard_step_text }}{% endblock %}
 
+{% block extrahead %}
+    {{ block.super }}
+    {{ form.media }}
+{% endblock %}
+
 {% block content %}
     {% include "admin/AKModel/event_wizard/wizard_steps.html" %}
 
-    {{ form.media }}
-
     <form method="post">{% csrf_token %}
         {% bootstrap_form form %}
 

AKModel/templates/admin/AKModel/event_wizard/settings.html

@@ -8,11 +8,14 @@
 
 {% block title %}{% trans "New event wizard" %}: {{ wizard_step_text }}{% endblock %}
 
+{% block extrahead %}
+    {{ block.super }}
+    {{ form.media }}
+{% endblock %}
+
 {% block content %}
     {% include "admin/AKModel/event_wizard/wizard_steps.html" %}
 
-    {{ form.media }}
-
     {% timezone timezone %}
 
     <form method="post">{% csrf_token %}

AKModel/templates/admin/AKModel/event_wizard/start.html

@@ -7,6 +7,11 @@
 
 {% block title %}{% trans "New event wizard" %}: {{ wizard_step_text }}{% endblock %}
 
+{% block extrahead %}
+    {{ block.super }}
+    {{ form.media }}
+{% endblock %}
+
 {% block content %}
     {% include "admin/AKModel/event_wizard/wizard_steps.html" %}
 

AKModel/templates/admin/AKModel/import_json.html

+{% extends "admin/base_site.html" %}
+{% load tags_AKModel %}
+
+{% load i18n %}
+{% load django_bootstrap5 %}
+{% load fontawesome_6 %}
+
+
+{% block title %}{{event}}: {{ title }}{% endblock %}
+
+{% block content %}
+    {% block action_preview %}
+        <p>
+            {{ preview|linebreaksbr }}
+        </p>
+    {% endblock %}
+
+    <form enctype="multipart/form-data" method="post">{% csrf_token %}
+        {% bootstrap_form form %}
+
+        <div class="float-end">
+            <button type="submit" class="save btn btn-success" value="Submit">
+                {% fa6_icon "check" 'fas' %} {% trans "Confirm" %}
+            </button>
+        </div>
+        <a href="javascript:history.back()" class="btn btn-info">
+            {% fa6_icon "times" 'fas' %} {% trans "Cancel" %}
+        </a>
+    </form>
+{% endblock %}

AKModel/templates/admin/AKModel/render_ak_messages.html

-<table class="table table-striped">
-{% for message in ak_messages %}
-    <tr><td>
-        <span class="text-secondary float-end">
-            {{ message.timestamp|date:"Y-m-d H:i:s" }}
-        </span>
-        <h5><a href="{{ message.ak.detail_url }}">{{ message.ak }}</a></h5>
-        <p>{{ message.text }}</p>
-    </td></tr>
-{% endfor %}
-</table>
+{% load tz %}
+{% load fontawesome_6 %}
+
+{% timezone event.timezone %}
+    <table class="table table-striped">
+    {% for message in ak_messages %}
+        <tr><td>
+            <span class="text-secondary float-end">
+                {{ message.timestamp|date:"Y-m-d H:i:s" }}
+            </span>
+            <h5><a href="{{ message.ak.detail_url }}">
+                {% if message.resolved %}{% fa6_icon "check-circle" %} {% endif %}
+                {{ message.ak }}
+            </a></h5>
+            <p>{{ message.text }}</p>
+        </td></tr>
+    {% endfor %}
+    </table>
+{% endtimezone %}

AKModel/templates/admin/AKModel/status.html

-{% extends "admin/base_site.html" %}
-{% load tags_AKModel %}
-
-{% load i18n %}
-{% load tz %}
-
-{% block title %}{% trans "Status" %}: {{event}}{% endblock %}
-
-{% block content %}
-    {% timezone event.timezone %}
-        <h2><a href="{% url 'admin:AKModel_event_change' event.pk %}">{{event}}</a></h2>
-        <h5>{{ event.start }} - {{ event.end }}</h5>
-
-        <div class="form-check form-switch mt-2 mb-2">
-          <input type="checkbox" class="form-check-input" id="planPublishedSwitch"
-                 {% if not event.plan_hidden %}checked{% endif %}
-                 onclick="location.href='{% if event.plan_hidden %}{% url 'admin:plan-publish' %}{% else %}{% url 'admin:plan-unpublish' %}{% endif %}?pks={{event.pk}}';">
-          <label class="form-check-label" for="planPublishedSwitch">{% trans "Plan published?" %}</label>
-        </div>
-
-        <div class="row">
-            <div class="col-md-8">
-                <h3 class="block-header">{% trans "Categories" %}</h3>
-                {% if event.akcategory_set.count == 0 %}
-                    <p class="text-danger">{% trans "No categories yet" %}</p>
-                {% else %}
-                    <p>
-                        {{ event.akcategory_set.count }}:
-                        {% for category in event.akcategory_set.all %}
-                            {% if forloop.counter0 > 0 %}
-                                &middot;
-                            {% endif %}
-                            <a href="{% url 'admin:AKModel_akcategory_change' category.pk %}">{{ category }}</a>
-                            ({{ category.ak_set.count }})
-                        {% endfor %}
-                    </p>
-                {% endif %}
-                <a class="btn btn-success" href="{% url 'admin:AKModel_akcategory_add' %}">{% trans "Add category" %}</a>
-
-                <h3 class="block-header">{% trans "Rooms" %}</h3>
-                {% if event.room_set.count == 0 %}
-                    <p class="text-danger">{% trans "No rooms yet" %}</p>
-                {% else %}
-                    <p>
-                        {{ event.room_set.count }}:
-                        {% for room in event.room_set.all %}
-                            {% if forloop.counter0 > 0 %}
-                                &middot;
-                            {% endif %}
-                            <a href="{% url 'admin:AKModel_room_change' room.pk %}">{{ room }}</a>
-                        {% endfor %}
-                    </p>
-                {% endif %}
-                <a class="btn btn-success" href="{% url 'admin:AKModel_room_add' %}">{% trans "Add Room" %}</a>
-                <a class="btn btn-success" href="{% url 'admin:room-import' event_slug=event.slug %}">{% trans "Import Rooms from CSV" %}</a>
-
-                <h3 class="block-header">{% trans "AKs" %}</h3>
-                {% if event.ak_set.count == 0 %}
-                    <p class="text-danger">{% trans "No AKs yet" %}</p>
-                {% else %}
-                    <table>
-                        <tbody>
-                            <tr>
-                                <td>{% trans "AKs" %}</td><td>{{ event.ak_set.count }}</td>
-                            </tr>
-                            <tr>
-                                <td>{% trans "Slots" %}</td><td>{{ event.akslot_set.count }}</td>
-                            </tr>
-                            <tr>
-                              <td>{% trans "Unscheduled Slots" %}</td><td>
-                                {% if "AKScheduling"|check_app_installed %}
-                                    <a href="{% url 'admin:slots_unscheduled' event_slug=event.slug %}">
-                                        {{ unscheduled_slots_count }}
-                                    </a>
-                                {% else %}
-                                    {{ unscheduled_slots_count }}
-                                {% endif %}
-                            </td>
-                            </tr>
-                        </tbody>
-                    </table>
-
-                    <a class="btn btn-success"
-                       href="{% url 'admin:schedule' event_slug=event.slug %}">{% trans "Scheduling" %}</a>
-                    {% if "AKScheduling | is_installed" %}
-                        <a class="btn btn-success"
-                            href="{% url 'admin:constraint-violations' slug=event.slug %}">{% trans "Constraint Violations" %} <span class="badge bg-secondary">{{ event.constraintviolation_set.count }}</span></a>
-                        <a class="btn btn-success"
-                            href="{% url 'admin:special-attention' slug=event.slug %}">{% trans "AKs requiring special attention" %}</a>
-                        <a class="btn btn-success"
-                            href="{% url 'admin:enter-interest' event_slug=event.slug pk=event.ak_set.all.first.pk %}">{% trans "Enter Interest" %}</a>
-                    {% endif %}
-                    <a class="btn btn-success"
-                       href="{% url 'admin:default-slots-editor' event_slug=event.slug %}">{% trans "Edit Default Slots" %}</a>
-                    <a class="btn btn-success"
-                       href="{% url 'admin:tracks_manage' event_slug=event.slug %}">{% trans "Manage ak tracks" %}</a>
-                    <a class="btn btn-success"
-                       href="{% url 'admin:ak_csv_export' event_slug=event.slug %}">{% trans "Export AKs as CSV" %}</a>
-                    <a class="btn btn-success"
-                       href="{% url 'admin:ak_wiki_export' slug=event.slug %}">{% trans "Export AKs for Wiki" %}</a>
-                    <a class="btn btn-success"
-                       href="{% url 'admin:ak_slide_export' event_slug=event.slug %}">{% trans "Export AK Slides" %}</a>
-                {% endif %}
-
-                <h3 class="block-header">{% trans "Requirements" %}</h3>
-                {% if event.akrequirement_set.count == 0 %}
-                    <p class="text-danger">{% trans "No requirements yet" %}</p>
-                {% else %}
-                    <p>
-                        {{ event.akrequirement_set.count }}:
-                        {% for requirement in event.akrequirement_set.all %}
-                            {% if forloop.counter0 > 0 %}
-                                &middot;
-                            {% endif %}
-                            <a href="{% url 'admin:AKModel_akrequirement_change' requirement.pk %}">{{ requirement }}</a>
-                            ({{ requirement.ak_set.count }})
-                        {% endfor %}
-                    </p>
-                {% endif %}
-                <a class="btn btn-success" href="{% url 'admin:event_requirement_overview' event.slug %}">{% trans "Show AKs for requirements" %}</a>
-                <a class="btn btn-success" href="{% url 'admin:AKModel_akrequirement_add' %}">{% trans "Add Requirement" %}</a>
-            </div>
-            <div class="col-md-4">
-                <h3 class="block-header">{% trans "Messages" %}</h3>
-                {% include "admin/AKModel/render_ak_messages.html" %}
-                <a class="btn btn-danger" href="{% url 'admin:ak_delete_orga_messages' event_slug=event.slug %}">{% trans "Delete all messages" %}</a>
-            </div>
-        </div>
-    {% endtimezone %}
-{% endblock %}

AKModel/templates/admin/AKModel/status/event_aks.html

+{% load i18n %}
+{% load tags_AKModel %}
+
+{% if event.ak_set.count == 0 %}
+    <p class="text-danger">{% trans "No AKs yet" %}</p>
+{% else %}
+    <table>
+        <tbody>
+            <tr>
+                <td>{% trans "AKs" %}</td><td>{{ ak_count }}</td>
+            </tr>
+            <tr>
+                <td>{% trans "Slots" %}</td><td>{{ event.akslot_set.count }}</td>
+            </tr>
+            <tr>
+              <td>{% trans "Unscheduled Slots" %}</td><td>
+                {% if "AKScheduling"|check_app_installed %}
+                    <a href="{% url 'admin:slots_unscheduled' event_slug=event.slug %}">
+                        {{ unscheduled_slots_count }}
+                    </a>
+                {% else %}
+                    {{ unscheduled_slots_count }}
+                {% endif %}
+            </td>
+            </tr>
+        </tbody>
+    </table>
+{% endif %}

AKModel/templates/admin/AKModel/status/event_categories.html

+{% load i18n %}
+
+{% if event.akcategory_set.count == 0 %}
+    <p class="text-danger">{% trans "No categories yet" %}</p>
+{% else %}
+    <ul>
+        {% for category in event.akcategory_set.all %}
+            <li>
+                <a href="{% url 'admin:AKModel_akcategory_change' category.pk %}">{{ category }}</a>
+            ({{ category.ak_set.count }})
+            </li>
+        {% endfor %}
+    </ul>
+{% endif %}

AKModel/templates/admin/AKModel/status/event_overview.html

+{% load i18n %}
+{% load tz %}
+
+{% timezone event.timezone %}
+    <h2><a href="{% url 'admin:AKModel_event_change' event.pk %}">{{event}}</a></h2>
+    <h5>{{ event.start }} - {{ event.end }}</h5>
+
+    <div class="form-check form-switch mt-2 mb-2">
+      <input type="checkbox" class="form-check-input" id="planPublishedSwitch"
+             {% if not event.plan_hidden %}checked{% endif %}
+             onclick="location.href='{% if event.plan_hidden %}{% url 'admin:plan-publish' %}{% else %}{% url 'admin:plan-unpublish' %}{% endif %}?pks={{event.pk}}';">
+      <label class="form-check-label" for="planPublishedSwitch">{% trans "Plan published?" %}</label>
+    </div>
+{% endtimezone %}

AKModel/templates/admin/AKModel/status/event_requirements.html

+{% load i18n %}
+
+{% if event.akrequirement_set.count == 0 %}
+    <p class="text-danger">{% trans "No requirements yet" %}</p>
+{% else %}
+    <ul>
+        {% for requirement in event.akrequirement_set.all %}
+            <li>
+                <a href="{% url 'admin:AKModel_akrequirement_change' requirement.pk %}">{{ requirement }}</a>
+            ({{ requirement.ak_set.count }})
+            </li>
+        {% endfor %}
+    </ul>
+{% endif %}

AKModel/templates/admin/AKModel/status/event_rooms.html

+{% load i18n %}
+
+{% if event.room_set.count == 0 %}
+    <p class="text-danger">{% trans "No rooms yet" %}</p>
+{% else %}
+    <p>
+        {% for room in event.room_set.all %}
+            {% if forloop.counter0 > 0 %}
+                &middot;
+            {% endif %}
+            <a href="{% url 'admin:AKModel_room_change' room.pk %}">{{ room }}</a>
+        {% endfor %}
+    </p>
+{% endif %}
+

AKModel/templates/admin/AKModel/status/status.html

+{% extends "admin/base_site.html" %}
+{% load tags_AKModel %}
+
+{% load i18n %}
+{% load tz %}
+{% load fontawesome_6 %}
+
+{% block title %}{% trans "Status" %}: {{ event }}{% endblock %}
+
+{% block content %}
+    {% timezone event.timezone %}
+        <div class="row">
+            {% for widget in widgets %}
+                <div class="card border-{{ widget.status }} mb-3 me-2 col-xl-3 col-md-4 col-sm-6 p-0">
+                    <div class="card-header">
+                        {% if widget.actions %}
+                            <div class="float-end">
+                                <a style="cursor: pointer;" data-bs-toggle="dropdown" aria-expanded="false">
+                                    &nbsp;{% fa6_icon "ellipsis-vertical" %}&nbsp;
+                                </a>
+                                <ul class="dropdown-menu dropdown-menu-end">
+                                    {% for action in widget.actions %}
+                                    <li class="dropdown-item">
+                                        <a href="{{ action.url }}">{{ action.text }}</a>
+                                    </li>
+                                    {% endfor %}
+                                </ul>
+                            </div>
+                        {% endif %}
+                        {{ widget.title }}
+                    </div>
+                    <div class="card-body">
+                        {{ widget.body }}
+                    </div>
+                </div>
+            {% endfor %}
+        </div>
+
+    {% endtimezone %}
+{% endblock %}

AKModel/templates/admin/ak_index.html

@@ -12,7 +12,7 @@
                     <a href="{% url 'admin:AKModel_event_change' event.pk %}">{{ event }}</a>
                     ({{ event.start|timezone:event.timezone|date:"d.m.y" }} -
                     {{ event.end|timezone:event.timezone|date:"d.m.y" }}) &middot;
-                    <a href="{% url 'admin:event_status' slug=event.slug %}">{% trans "Status" %}</a> &middot;
+                    <a href="{% url 'admin:event_status' event_slug=event.slug %}">{% trans "Status" %}</a> &middot;
                     <a href="{% url 'admin:schedule' event_slug=event.slug %}">{% trans "Scheduling" %}</a>
                 </li>
             {% endfor %}

AKModel/templatetags/tags_AKModel.py

@@ -3,35 +3,65 @@ from django.apps import apps
 from django.conf import settings
 from django.utils.html import format_html, mark_safe, conditional_escape
 from django.templatetags.static import static
+from django.template.defaultfilters import date
 from fontawesome_6.app_settings import get_css
 
+from AKModel.models import Event
+
 register = template.Library()
 
 
-# Get Footer Info from settings
 @register.simple_tag
 def footer_info():
+    """
+    Get Footer Info from settings
+
+    :return: a dict of several strings like the impress URL to use in the footer
+    :rtype: Dict[str, str]
+    """
     return settings.FOOTER_INFO
 
 
 @register.filter
 def check_app_installed(name):
+    """
+    Check whether the app with the given name is active in this instance
+
+    :param name: name of the app to check for
+    :return: true if app is installed
+    :rtype: bool
+    """
     return apps.is_installed(name)
 
 
 @register.filter
 def message_bootstrap_class(tag):
+    """
+    Turn message severity classes into corresponding bootstrap css classes
+
+    :param tag: severity of the message
+    :return: matching bootstrap class
+    """
     if tag == "error":
         return "alert-danger"
-    elif tag == "success":
+    if tag == "success":
         return "alert-success"
-    elif tag == "warning":
+    if tag == "warning":
         return "alert-warning"
     return "alert-info"
 
 
 @register.filter
 def wiki_owners_export(owners, event):
+    """
+    Preserve owner link information for wiki export by using internal links if possible
+    but external links when owner specified a non-wikilink. This is applied to the full list of owners
+
+    :param owners: list of owners
+    :param event: event this owner belongs to and that is currently exported (specifying this directly prevents unnecessary database lookups) #pylint: disable=line-too-long
+    :return: linkified owners list in wiki syntax
+    :rtype: str
+    """
     def to_link(owner):
         if owner.link != '':
             event_link_prefix, _ = event.base_url.rsplit("/", 1)
@@ -44,17 +74,45 @@ def wiki_owners_export(owners, event):
     return ", ".join(to_link(owner) for owner in owners.all())
 
 
+@register.filter
+def event_month_year(event:Event):
+    """
+    Print rough event date (month and year)
+    :param event: event to print the date for
+    :return: string containing rough date information for event
+    """
+    if event.start.month == event.end.month:
+        return f"{date(event.start, 'F')} {event.start.year}"
+    event_start_string = date(event.start, 'F')
+    if event.start.year != event.end.year:
+        event_start_string = f"{event_start_string} {event.start.year}"
+    return f"{event_start_string} - {date(event.end, 'F')} {event.end.year}"
+
+
+# get list of relevant css fontawesome css files for this instance
 css = get_css()
 
 
 @register.simple_tag
 def fontawesome_6_css():
+    """
+    Create html code to load all required fontawesome css files
+
+    :return: HTML code to load css
+    :rtype: str
+    """
     return mark_safe(conditional_escape('\n').join(format_html(
             '<link href="{}" rel="stylesheet" media="all">', stylesheet) for stylesheet in css))
 
 
 @register.simple_tag
 def fontawesome_6_js():
+    """
+    Create html code to load all required fontawesome javascript files
+
+    :return: HTML code to load js
+    :rtype: str
+    """
     return mark_safe(format_html(
         '<script type="text/javascript" src="{}"></script>', static('fontawesome_6/js/django-fontawesome.js')
-    ))
\ No newline at end of file
+    ))

AKModel/tests/test_json_export.py

+import json
+import math
+from collections import defaultdict
+from collections.abc import Iterable
+from datetime import datetime, timedelta
+from itertools import chain
+
+from bs4 import BeautifulSoup
+from django.contrib.auth import get_user_model
+from django.test import TestCase
+from django.urls import reverse
+from jsonschema.exceptions import best_match
+
+from AKModel.availability.models import Availability
+from AKModel.models import AK, AKCategory, AKOwner, AKSlot, DefaultSlot, Event, Room
+from AKModel.utils import construct_schema_validator
+
+
+class JSONExportTest(TestCase):
+    """Test if JSON export is correct.
+
+    It tests if the output conforms to the KoMa specification:
+    https://github.com/Die-KoMa/ak-plan-optimierung/wiki/Input-&-output-format
+    """
+
+    fixtures = ["model.json"]
+
+    @classmethod
+    def setUpTestData(cls):
+        """Shared set up by initializing admin user."""
+        cls.admin_user = get_user_model().objects.create(
+            username="Test Admin User",
+            email="testadmin@example.com",
+            password="adminpw",
+            is_staff=True,
+            is_superuser=True,
+            is_active=True,
+        )
+
+        cls.json_export_validator = construct_schema_validator(
+            "solver-input-export.schema.json"
+        )
+
+    def setUp(self):
+        self.client.force_login(self.admin_user)
+        self.export_dict = {}
+        self.export_objects = {
+            "aks": {},
+            "rooms": {},
+            "participants": {},
+        }
+
+        self.ak_slots: Iterable[AKSlot] = []
+        self.rooms: Iterable[Room] = []
+        self.slots_in_an_hour: float = 1.0
+        self.event: Event | None = None
+
+    def set_up_event(self, event: Event) -> None:
+        """Set up by retrieving json export and initializing data."""
+
+        export_url = reverse("admin:ak_json_export", kwargs={"event_slug": event.slug})
+        response = self.client.get(export_url)
+
+        self.assertEqual(response.status_code, 200, "Export not working at all")
+
+        soup = BeautifulSoup(response.content, features="lxml")
+        self.export_dict = json.loads(soup.find("pre").string)
+
+        self.export_objects["aks"] = {ak["id"]: ak for ak in self.export_dict["aks"]}
+        self.export_objects["rooms"] = {
+            room["id"]: room for room in self.export_dict["rooms"]
+        }
+        self.export_objects["participants"] = {
+            participant["id"]: participant
+            for participant in self.export_dict["participants"]
+        }
+
+        self.ak_slots = (
+            AKSlot.objects.filter(event__slug=event.slug)
+            .select_related("ak")
+            .prefetch_related("ak__conflicts")
+            .prefetch_related("ak__prerequisites")
+            .all()
+        )
+        self.rooms = Room.objects.filter(event__slug=event.slug).all()
+        self.slots_in_an_hour = 1 / self.export_dict["timeslots"]["info"]["duration"]
+        self.event = event
+
+    def test_all_aks_exported(self):
+        """Test if exported AKs match AKSlots of Event."""
+        for event in Event.objects.all():
+            with self.subTest(event=event):
+                self.set_up_event(event=event)
+                self.assertEqual(
+                    {slot.pk for slot in self.ak_slots},
+                    self.export_objects["aks"].keys(),
+                    "Exported AKs does not match the AKSlots of the event",
+                )
+
+    def _check_uniqueness(self, lst, name: str, key: str | None = "id"):
+        if key is not None:
+            lst = [entry[key] for entry in lst]
+        self.assertEqual(len(lst), len(set(lst)), f"{name} IDs not unique!")
+
+    def _check_type(self, attr, cls, name: str, item: str) -> None:
+        self.assertTrue(isinstance(attr, cls), f"{item} {name} not a {cls}")
+
+    def _check_lst(
+        self, lst: list[str], name: str, item: str, contained_type=str
+    ) -> None:
+        self.assertTrue(isinstance(lst, list), f"{item} {name} not a list")
+        self.assertTrue(
+            all(isinstance(c, contained_type) for c in lst),
+            f"{item} has non-{contained_type} {name}",
+        )
+        if contained_type in {str, int}:
+            self._check_uniqueness(lst, name, key=None)
+
+    def test_conformity_to_schema(self):
+        """Test if JSON structure and types conform to schema."""
+        for event in Event.objects.all():
+            with self.subTest(event=event):
+                self.set_up_event(event=event)
+
+                error = best_match(
+                    self.json_export_validator.iter_errors(self.export_dict)
+                )
+                msg = "" if not error else f"{error.message} at {error.json_path}"
+                self.assertFalse(error, msg)
+
+    def test_id_uniqueness(self):
+        """Test if objects are only exported once."""
+        for event in Event.objects.all():
+            with self.subTest(event=event):
+                self.set_up_event(event=event)
+
+                self._check_uniqueness(self.export_dict["aks"], "AKs")
+                self._check_uniqueness(self.export_dict["rooms"], "Rooms")
+                self._check_uniqueness(self.export_dict["participants"], "Participants")
+
+                self._check_uniqueness(
+                    chain.from_iterable(self.export_dict["timeslots"]["blocks"]),
+                    "Timeslots",
+                )
+
+    def test_timeslot_ids_consecutive(self):
+        """Test if Timeslots ids are chronologically consecutive."""
+        for event in Event.objects.all():
+            with self.subTest(event=event):
+                self.set_up_event(event=event)
+
+                prev_id = None
+                for timeslot in chain.from_iterable(
+                    self.export_dict["timeslots"]["blocks"]
+                ):
+                    if prev_id is not None:
+                        self.assertLess(
+                            prev_id,
+                            timeslot["id"],
+                            "timeslot ids must be increasing",
+                        )
+                    prev_id = timeslot["id"]
+
+    def test_general_conformity_to_spec(self):
+        """Test if rest of JSON structure and types conform to standard."""
+        for event in Event.objects.all():
+            with self.subTest(event=event):
+                self.set_up_event(event=event)
+
+                self.assertEqual(
+                    self.export_dict["participants"],
+                    [],
+                    "Empty participant list expected",
+                )
+
+                info_keys = {"title": "name", "slug": "slug"}
+                for attr in ["contact_email", "place"]:
+                    if hasattr(self.event, attr) and getattr(self.event, attr):
+                        info_keys[attr] = attr
+                self.assertEqual(
+                    self.export_dict["info"].keys(),
+                    info_keys.keys(),
+                    "info keys not as expected",
+                )
+                for attr, attr_field in info_keys.items():
+                    self.assertEqual(
+                        getattr(self.event, attr_field), self.export_dict["info"][attr]
+                    )
+
+    def test_ak_durations(self):
+        """Test if all AK durations are correct."""
+        for event in Event.objects.all():
+            with self.subTest(event=event):
+                self.set_up_event(event=event)
+
+                for slot in self.ak_slots:
+                    ak = self.export_objects["aks"][slot.pk]
+
+                    self.assertLessEqual(
+                        float(slot.duration) * self.slots_in_an_hour - 1e-4,
+                        ak["duration"],
+                        "Slot duration is too short",
+                    )
+
+                    self.assertEqual(
+                        math.ceil(float(slot.duration) * self.slots_in_an_hour - 1e-4),
+                        ak["duration"],
+                        "Slot duration is wrong",
+                    )
+
+                    self.assertEqual(
+                        float(slot.duration),
+                        ak["info"]["duration_in_hours"],
+                        "Slot duration_in_hours is wrong",
+                    )
+
+    def test_ak_conflicts(self):
+        """Test if all AK conflicts are correct."""
+        for event in Event.objects.all():
+            with self.subTest(event=event):
+                self.set_up_event(event=event)
+
+                for slot in self.ak_slots:
+                    ak = self.export_objects["aks"][slot.pk]
+                    conflict_slots = set(
+                        self.ak_slots.filter(
+                            ak__in=slot.ak.conflicts.all()
+                        ).values_list("pk", flat=True)
+                    )
+
+                    other_ak_slots = (
+                        self.ak_slots.filter(ak=slot.ak)
+                        .exclude(pk=slot.pk)
+                        .values_list("pk", flat=True)
+                    )
+                    conflict_slots.update(other_ak_slots)
+
+                    self.assertEqual(
+                        conflict_slots,
+                        set(ak["properties"]["conflicts"]),
+                        f"Conflicts for slot {slot.pk} not as expected",
+                    )
+
+    def test_ak_depenedencies(self):
+        """Test if all AK dependencies are correct."""
+        for event in Event.objects.all():
+            with self.subTest(event=event):
+                self.set_up_event(event=event)
+
+                for slot in self.ak_slots:
+                    ak = self.export_objects["aks"][slot.pk]
+                    dependency_slots = self.ak_slots.filter(
+                        ak__in=slot.ak.prerequisites.all()
+                    ).values_list("pk", flat=True)
+
+                    self.assertEqual(
+                        set(dependency_slots),
+                        set(ak["properties"]["dependencies"]),
+                        f"Dependencies for slot {slot.pk} not as expected",
+                    )
+
+    def test_ak_reso(self):
+        """Test if resolution intent of AKs is correctly exported."""
+        for event in Event.objects.all():
+            with self.subTest(event=event):
+                self.set_up_event(event=event)
+
+                for slot in self.ak_slots:
+                    ak = self.export_objects["aks"][slot.pk]
+                    self.assertEqual(slot.ak.reso, ak["info"]["reso"])
+                    self.assertEqual(
+                        slot.ak.reso, "resolution" in ak["time_constraints"]
+                    )
+
+    def test_ak_info(self):
+        """Test if contents of AK info dict is correct."""
+        for event in Event.objects.all():
+            with self.subTest(event=event):
+                self.set_up_event(event=event)
+
+                for slot in self.ak_slots:
+                    ak = self.export_objects["aks"][slot.pk]
+                    self.assertEqual(ak["info"]["name"], slot.ak.name)
+                    self.assertEqual(
+                        ak["info"]["head"], ", ".join(map(str, slot.ak.owners.all()))
+                    )
+                    self.assertEqual(ak["info"]["description"], slot.ak.description)
+                    self.assertEqual(ak["info"]["django_ak_id"], slot.ak.pk)
+                    self.assertEqual(
+                        ak["info"]["types"],
+                        list(slot.ak.types.values_list("name", flat=True).order_by()),
+                    )
+
+    def test_ak_room_constraints(self):
+        """Test if AK room constraints are exported as expected."""
+        for event in Event.objects.all():
+            with self.subTest(event=event):
+                self.set_up_event(event=event)
+
+                for slot in self.ak_slots:
+                    ak = self.export_objects["aks"][slot.pk]
+                    requirements = list(
+                        slot.ak.requirements.values_list("name", flat=True)
+                    )
+
+                    # proxy rooms
+                    if not any(constr.startswith("proxy") for constr in requirements):
+                        requirements.append("no-proxy")
+
+                    # fixed slot
+                    if slot.fixed and slot.room is not None:
+                        requirements.append(f"fixed-room-{slot.room.pk}")
+
+                    self.assertEqual(
+                        set(ak["room_constraints"]),
+                        set(requirements),
+                        f"Room constraints for slot {slot.pk} not as expected",
+                    )
+
+    def test_ak_time_constraints(self):
+        """Test if AK time constraints are exported as expected."""
+        for event in Event.objects.all():
+            with self.subTest(event=event):
+                self.set_up_event(event=event)
+
+                for slot in self.ak_slots:
+                    time_constraints = set()
+
+                    # add time constraints for AK category
+                    if slot.ak.category:
+                        category_constraints = AKCategory.create_category_optimizer_constraints(
+                            [slot.ak.category]
+                        )
+                        time_constraints |= category_constraints
+
+                    if slot.fixed and slot.start is not None:
+                        # fixed slot
+                        time_constraints.add(f"fixed-akslot-{slot.pk}")
+                    elif not Availability.is_event_covered(
+                        slot.event, slot.ak.availabilities.all()
+                    ):
+                        # restricted AK availability
+                        time_constraints.add(f"availability-ak-{slot.ak.pk}")
+
+                    for owner in slot.ak.owners.all():
+                        # restricted owner availability
+                        if not owner.availabilities.all():
+                            # no availability for owner -> assume full event is covered
+                            continue
+
+                        if not Availability.is_event_covered(
+                            slot.event, owner.availabilities.all()
+                        ):
+                            time_constraints.add(f"availability-person-{owner.pk}")
+
+                    ak = self.export_objects["aks"][slot.pk]
+                    self.assertEqual(
+                        set(ak["time_constraints"]),
+                        time_constraints,
+                        f"Time constraints for slot {slot.pk} not as expected",
+                    )
+
+    def test_all_rooms_exported(self):
+        """Test if exported Rooms match the rooms of Event."""
+        for event in Event.objects.all():
+            with self.subTest(event=event):
+                self.set_up_event(event=event)
+
+                self.assertEqual(
+                    {room.pk for room in self.rooms},
+                    self.export_objects["rooms"].keys(),
+                    "Exported Rooms do not match the Rooms of the event",
+                )
+
+    def test_room_capacity(self):
+        """Test if room capacity is exported correctly."""
+        for event in Event.objects.all():
+            with self.subTest(event=event):
+                self.set_up_event(event=event)
+
+                for room in self.rooms:
+                    export_room = self.export_objects["rooms"][room.pk]
+                    self.assertEqual(room.capacity, export_room["capacity"])
+
+    def test_room_info(self):
+        """Test if contents of Room info dict is correct."""
+        for event in Event.objects.all():
+            with self.subTest(event=event):
+                self.set_up_event(event=event)
+
+                for room in self.rooms:
+                    export_room = self.export_objects["rooms"][room.pk]
+                    self.assertEqual(room.name, export_room["info"]["name"])
+
+    def test_room_timeconstraints(self):
+        """Test if Room time constraints are exported as expected."""
+        for event in Event.objects.all():
+            with self.subTest(event=event):
+                self.set_up_event(event=event)
+
+                for room in self.rooms:
+                    time_constraints = set()
+
+                    # test if time availability of room is restricted
+                    if not Availability.is_event_covered(
+                        event, room.availabilities.all()
+                    ):
+                        time_constraints.add(f"availability-room-{room.pk}")
+
+                    export_room = self.export_objects["rooms"][room.pk]
+                    self.assertEqual(
+                        time_constraints, set(export_room["time_constraints"])
+                    )
+
+    def test_room_fulfilledroomconstraints(self):
+        """Test if room constraints fulfilled by Room are correct."""
+        for event in Event.objects.all():
+            with self.subTest(event=event):
+                self.set_up_event(event=event)
+
+                for room in self.rooms:
+                    # room properties
+                    fulfilled_room_constraints = set(
+                        room.properties.values_list("name", flat=True)
+                    )
+
+                    # proxy rooms
+                    if not any(
+                        constr.startswith("proxy")
+                        for constr in fulfilled_room_constraints
+                    ):
+                        fulfilled_room_constraints.add("no-proxy")
+
+                    fulfilled_room_constraints.add(f"fixed-room-{room.pk}")
+
+                    export_room = self.export_objects["rooms"][room.pk]
+                    self.assertEqual(
+                        fulfilled_room_constraints,
+                        set(export_room["fulfilled_room_constraints"]),
+                    )
+
+    def _get_timeslot_start_end(self, timeslot):
+        start = datetime.strptime(timeslot["info"]["start"], "%Y-%m-%d %H:%M").replace(
+            tzinfo=self.event.timezone
+        )
+        end = datetime.strptime(timeslot["info"]["end"], "%Y-%m-%d %H:%M").replace(
+            tzinfo=self.event.timezone
+        )
+        return start, end
+
+    def _get_cat_availability_in_export(self):
+        export_slot_cat_avails = defaultdict(list)
+        for timeslot in chain.from_iterable(self.export_dict["timeslots"]["blocks"]):
+            for constr in timeslot["fulfilled_time_constraints"]:
+                if constr.startswith("availability-cat-"):
+                    cat_name = constr[len("availability-cat-") :]
+                    start, end = self._get_timeslot_start_end(timeslot)
+                    export_slot_cat_avails[cat_name].append(
+                        Availability(event=self.event, start=start, end=end)
+                    )
+        return {
+            cat_name: Availability.union(avail_lst)
+            for cat_name, avail_lst in export_slot_cat_avails.items()
+        }
+
+    def _get_cat_availability(self):
+        if DefaultSlot.objects.filter(event=self.event).exists():
+            # Event has default slots -> use them for category availability
+            default_slots_avails = defaultdict(list)
+            for def_slot in DefaultSlot.objects.filter(event=self.event).all():
+                avail = Availability(
+                    event=self.event,
+                    start=def_slot.start.astimezone(self.event.timezone),
+                    end=def_slot.end.astimezone(self.event.timezone),
+                )
+                for cat in def_slot.primary_categories.all():
+                    default_slots_avails[cat.name].append(avail)
+
+            return {
+                cat_name: Availability.union(avail_lst)
+                for cat_name, avail_lst in default_slots_avails.items()
+            }
+
+        # Event has no default slots -> all categories available through whole event
+        start = self.event.start.astimezone(self.event.timezone)
+        end = self.event.end.astimezone(self.event.timezone)
+        delta = (end - start).total_seconds()
+
+        # tweak event end
+        # 1. shorten event to match discrete slot grid
+        slot_seconds = 3600 / self.slots_in_an_hour
+        remainder_seconds = delta % slot_seconds
+        remainder_seconds += 1  # add a second to compensate rounding errs
+        end -= timedelta(seconds=remainder_seconds)
+
+        # set seconds and microseconds to 0 as they are not exported to the json
+        start -= timedelta(seconds=start.second, microseconds=start.microsecond)
+        end -= timedelta(seconds=end.second, microseconds=end.microsecond)
+        event_avail = Availability(event=self.event, start=start, end=end)
+
+        category_names = AKCategory.objects.filter(event=self.event).values_list(
+            "name", flat=True
+        )
+        return {cat_name: [event_avail] for cat_name in category_names}
+
+    def test_timeslots_consecutive(self):
+        """Test if consecutive timeslots in JSON are in fact consecutive."""
+        for event in Event.objects.all():
+            with self.subTest(event=event):
+                self.set_up_event(event=event)
+
+                prev_end = None
+                for timeslot in chain.from_iterable(
+                    self.export_dict["timeslots"]["blocks"]
+                ):
+                    start, end = self._get_timeslot_start_end(timeslot)
+                    self.assertLess(start, end)
+
+                    delta = end - start
+                    self.assertAlmostEqual(
+                        delta.total_seconds() / (3600), 1 / self.slots_in_an_hour
+                    )
+
+                    if prev_end is not None:
+                        self.assertLessEqual(prev_end, start)
+                    prev_end = end
+
+    def test_block_cover_categories(self):
+        """Test if blocks covers all default slot resp. whole event per category."""
+        for event in Event.objects.all():
+            with self.subTest(event=event):
+                self.set_up_event(event=event)
+                category_names = AKCategory.objects.filter(event=event).values_list(
+                    "name", flat=True
+                )
+
+                export_cat_avails = self._get_cat_availability_in_export()
+                cat_avails = self._get_cat_availability()
+
+                for cat_name in category_names:
+                    for avail in cat_avails[cat_name]:
+                        # check that all category availabilities are covered
+                        self.assertTrue(
+                            avail.is_covered(export_cat_avails[cat_name]),
+                            f"AKCategory {cat_name}: avail ({avail.start} - {avail.end}) "
+                            f"not covered by {[f'({a.start} - {a.end})' for a in export_cat_avails[cat_name]]}",
+                        )
+
+    def _is_restricted_and_contained_slot(
+        self, slot: Availability, availabilities: list[Availability]
+    ) -> bool:
+        """Test if object is not available for whole event and may happen during slot."""
+        return slot.is_covered(availabilities) and not Availability.is_event_covered(
+            self.event, availabilities
+        )
+
+    def _is_ak_fixed_in_slot(
+        self,
+        ak_slot: AKSlot,
+        timeslot_avail: Availability,
+    ) -> bool:
+        if not ak_slot.fixed or ak_slot.start is None:
+            return False
+        ak_slot_avail = Availability(
+            event=self.event,
+            start=ak_slot.start.astimezone(self.event.timezone),
+            end=ak_slot.end.astimezone(self.event.timezone),
+        )
+        return timeslot_avail.overlaps(ak_slot_avail, strict=True)
+
+    def test_timeslot_fulfilledconstraints(self):
+        """Test if fulfilled time constraints by timeslot are as expected."""
+        for event in Event.objects.all():
+            with self.subTest(event=event):
+                self.set_up_event(event=event)
+
+                cat_avails = self._get_cat_availability()
+                num_blocks = len(self.export_dict["timeslots"]["blocks"])
+                for block_idx, block in enumerate(
+                    self.export_dict["timeslots"]["blocks"]
+                ):
+                    for timeslot in block:
+                        start, end = self._get_timeslot_start_end(timeslot)
+                        timeslot_avail = Availability(
+                            event=self.event, start=start, end=end
+                        )
+
+                        fulfilled_time_constraints = set()
+
+                        # reso deadline
+                        if self.event.reso_deadline is not None:
+                            # timeslot ends before deadline
+                            if end < self.event.reso_deadline.astimezone(
+                                self.event.timezone
+                            ):
+                                fulfilled_time_constraints.add("resolution")
+
+                        # add category constraints
+                        fulfilled_time_constraints |= (
+                            AKCategory.create_category_optimizer_constraints(
+                                [
+                                    cat
+                                    for cat in AKCategory.objects.filter(
+                                        event=self.event
+                                    ).all()
+                                    if timeslot_avail.is_covered(cat_avails[cat.name])
+                                ]
+                            )
+                        )
+
+                        # add owner constraints
+                        fulfilled_time_constraints |= {
+                            f"availability-person-{owner.id}"
+                            for owner in AKOwner.objects.filter(event=self.event).all()
+                            if self._is_restricted_and_contained_slot(
+                                timeslot_avail,
+                                Availability.union(owner.availabilities.all()),
+                            )
+                        }
+
+                        # add room constraints
+                        fulfilled_time_constraints |= {
+                            f"availability-room-{room.id}"
+                            for room in self.rooms
+                            if self._is_restricted_and_contained_slot(
+                                timeslot_avail,
+                                Availability.union(room.availabilities.all()),
+                            )
+                        }
+
+                        # add ak constraints
+                        fulfilled_time_constraints |= {
+                            f"availability-ak-{ak.id}"
+                            for ak in AK.objects.filter(event=event)
+                            if self._is_restricted_and_contained_slot(
+                                timeslot_avail,
+                                Availability.union(ak.availabilities.all()),
+                            )
+                        }
+                        fulfilled_time_constraints |= {
+                            f"fixed-akslot-{slot.id}"
+                            for slot in self.ak_slots
+                            if self._is_ak_fixed_in_slot(slot, timeslot_avail)
+                        }
+
+                        fulfilled_time_constraints |= {
+                            f"notblock{idx}"
+                            for idx in range(num_blocks)
+                            if idx != block_idx
+                        }
+
+                        self.assertEqual(
+                            fulfilled_time_constraints,
+                            set(timeslot["fulfilled_time_constraints"]),
+                        )
+
+    def test_timeslots_info(self):
+        """Test timeslots info dict"""
+        for event in Event.objects.all():
+            with self.subTest(event=event):
+                self.set_up_event(event=event)
+
+                self.assertAlmostEqual(
+                    self.export_dict["timeslots"]["info"]["duration"],
+                    float(self.event.export_slot),
+                )
+
+                block_names = []
+                for block in self.export_dict["timeslots"]["blocks"]:
+                    if not block:
+                        continue
+
+                    block_start, _ = self._get_timeslot_start_end(block[0])
+                    _, block_end = self._get_timeslot_start_end(block[-1])
+
+                    start_day = block_start.strftime("%A, %d. %b")
+                    if block_start.date() == block_end.date():
+                        # same day
+                        time_str = (
+                            block_start.strftime("%H:%M")
+                            + " - "
+                            + block_end.strftime("%H:%M")
+                        )
+                    else:
+                        # different days
+                        time_str = (
+                            block_start.strftime("%a %H:%M")
+                            + " - "
+                            + block_end.strftime("%a %H:%M")
+                        )
+                    block_names.append([start_day, time_str])
+                self.assertEqual(
+                    block_names, self.export_dict["timeslots"]["info"]["blocknames"]
+                )

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

 import traceback
 from typing import List
 
-from django.contrib.auth.models import User
+from django.contrib.auth import get_user_model
 from django.contrib.messages import get_messages
 from django.contrib.messages.storage.base import Message
 from django.test import TestCase
 from django.urls import reverse_lazy, reverse
 
-from AKModel.models import Event, AKOwner, AKCategory, AKTrack, AKRequirement, AK, Room, AKSlot, AKOrgaMessage, \
-    ConstraintViolation, DefaultSlot
+from AKModel.models import (
+    Event,
+    AKOwner,
+    AKCategory,
+    AKTrack,
+    AKRequirement,
+    AK,
+    Room,
+    AKSlot,
+    AKOrgaMessage,
+    ConstraintViolation,
+    DefaultSlot,
+)
 
 
 class BasicViewTests:
+    """
+    Parent class for "standard" tests of views
+
+    Provided with a list of views and arguments (if necessary), this will test that views
+    - render correctly without errors
+    - are only reachable with the correct rights (neither too freely nor too restricted)
+
+    To do this, the test creates sample users, fixtures are loaded automatically by the django test framework.
+    It also provides helper functions, e.g., to check for correct messages to the user or more simply generate
+    the URLs to test
+
+    In this class, methods from :class:`TestCase` will be called at multiple places event though TestCase is not a
+    parent of this class but has to be included as parent in concrete implementations of this class seperately.
+    It however still makes sense to treat this class as some kind of mixin and not implement it as a child of TestCase,
+    since the test framework does not understand the concept of abstract test definitions and would handle this class
+    as real test case otherwise, distorting the test results.
+    """
+
+    # pylint: disable=no-member
     VIEWS = []
-    APP_NAME = ''
+    APP_NAME = ""
     VIEWS_STAFF_ONLY = []
     EDIT_TESTCASES = []
 
-    def setUp(self):
-        self.staff_user = User.objects.create(
-            username='Test Staff User', email='teststaff@example.com', password='staffpw',
-            is_staff=True, is_active=True
+    def setUp(self):  # pylint: disable=invalid-name
+        """
+        Setup testing by creating sample users
+        """
+        user_model = get_user_model()
+        self.staff_user = user_model.objects.create(
+            username="Test Staff User",
+            email="teststaff@example.com",
+            password="staffpw",
+            is_staff=True,
+            is_active=True,
         )
-        self.admin_user = User.objects.create(
-            username='Test Admin User', email='testadmin@example.com', password='adminpw',
-            is_staff=True, is_superuser=True, is_active=True
+        self.admin_user = user_model.objects.create(
+            username="Test Admin User",
+            email="testadmin@example.com",
+            password="adminpw",
+            is_staff=True,
+            is_superuser=True,
+            is_active=True,
         )
-        self.deactivated_user = User.objects.create(
-            username='Test Deactivated User', email='testdeactivated@example.com', password='deactivatedpw',
-            is_staff=True, is_active=False
+        self.deactivated_user = user_model.objects.create(
+            username="Test Deactivated User",
+            email="testdeactivated@example.com",
+            password="deactivatedpw",
+            is_staff=True,
+            is_active=False,
         )
 
     def _name_and_url(self, view_name):
@@ -40,12 +84,21 @@ class BasicViewTests:
         :return: full view name with prefix if applicable, url of the view
         :rtype: str, str
         """
-        view_name_with_prefix = f"{self.APP_NAME}:{view_name[0]}" if self.APP_NAME != "" else view_name[0]
+        view_name_with_prefix = (
+            f"{self.APP_NAME}:{view_name[0]}" if self.APP_NAME != "" else view_name[0]
+        )
         url = reverse(view_name_with_prefix, kwargs=view_name[1])
         return view_name_with_prefix, url
 
     def _assert_message(self, response, expected_message, msg_prefix=""):
-        messages:List[Message] = list(get_messages(response.wsgi_request))
+        """
+        Assert that the correct message is shown and cause test to fail if not
+
+        :param response: response to check
+        :param expected_message: message that should be shown
+        :param msg_prefix: prefix for the error message when test fails
+        """
+        messages: List[Message] = list(get_messages(response.wsgi_request))
 
         msg_count = "No message shown to user"
         msg_content = "Wrong message, expected '{expected_message}'"
@@ -59,60 +112,104 @@ class BasicViewTests:
         self.assertEqual(messages[-1].message, expected_message, msg=msg_content)
 
     def test_views_for_200(self):
+        """
+        Test the list of public views (as specified in "VIEWS") for error-free rendering
+        """
         for view_name in self.VIEWS:
             view_name_with_prefix, url = self._name_and_url(view_name)
             try:
                 response = self.client.get(url)
-                self.assertEqual(response.status_code, 200, msg=f"{view_name_with_prefix} ({url}) broken")
-            except Exception as e:
-                self.fail(f"An error occurred during rendering of {view_name_with_prefix} ({url}):\n\n{traceback.format_exc()}")
+                self.assertEqual(
+                    response.status_code,
+                    200,
+                    msg=f"{view_name_with_prefix} ({url}) broken",
+                )
+            except Exception:  # pylint: disable=broad-exception-caught
+                self.fail(
+                    f"An error occurred during rendering of {view_name_with_prefix} ({url}):"
+                    f"\n\n{traceback.format_exc()}"
+                )
 
     def test_access_control_staff_only(self):
+        """
+        Test whether internal views (as specified in "VIEWS_STAFF_ONLY" are visible to staff users and staff users only
+        """
+        # Not logged in? Views should not be visible
         self.client.logout()
-        for view_name in self.VIEWS_STAFF_ONLY:
-            view_name_with_prefix, url = self._name_and_url(view_name)
+        for view_name_info in self.VIEWS_STAFF_ONLY:
+            expected_response_code = (
+                302 if len(view_name_info) == 2 else view_name_info[2]
+            )
+            view_name_with_prefix, url = self._name_and_url(view_name_info)
             response = self.client.get(url)
-            self.assertEqual(response.status_code, 302, msg=f"{view_name_with_prefix} ({url}) accessible by non-staff")
+            self.assertEqual(
+                response.status_code,
+                expected_response_code,
+                msg=f"{view_name_with_prefix} ({url}) accessible by non-staff",
+            )
 
+        # Logged in? Views should be visible
         self.client.force_login(self.staff_user)
-        for view_name in self.VIEWS_STAFF_ONLY:
-            view_name_with_prefix, url = self._name_and_url(view_name)
+        for view_name_info in self.VIEWS_STAFF_ONLY:
+            view_name_with_prefix, url = self._name_and_url(view_name_info)
             try:
                 response = self.client.get(url)
-                self.assertEqual(response.status_code, 200,
-                                 msg=f"{view_name_with_prefix} ({url}) should be accessible for staff (but isn't)")
-            except Exception as e:
-                self.fail(f"An error occurred during rendering of {view_name_with_prefix} ({url}):\n\n{traceback.format_exc()}")
-
+                self.assertEqual(
+                    response.status_code,
+                    200,
+                    msg=f"{view_name_with_prefix} ({url}) should be accessible for staff (but isn't)",
+                )
+            except Exception:  # pylint: disable=broad-exception-caught
+                self.fail(
+                    f"An error occurred during rendering of {view_name_with_prefix} ({url}):"
+                    f"\n\n{traceback.format_exc()}"
+                )
+
+        # Disabled user? Views should not be visible
         self.client.force_login(self.deactivated_user)
-        for view_name in self.VIEWS_STAFF_ONLY:
-            view_name_with_prefix, url = self._name_and_url(view_name)
+        for view_name_info in self.VIEWS_STAFF_ONLY:
+            expected_response_code = (
+                302 if len(view_name_info) == 2 else view_name_info[2]
+            )
+            view_name_with_prefix, url = self._name_and_url(view_name_info)
             response = self.client.get(url)
-            self.assertEqual(response.status_code, 302,
-                             msg=f"{view_name_with_prefix} ({url}) still accessible for deactivated user")
+            self.assertEqual(
+                response.status_code,
+                expected_response_code,
+                msg=f"{view_name_with_prefix} ({url}) still accessible for deactivated user",
+            )
 
-    def _to_sendable_value(self, v):
+    def _to_sendable_value(self, val):
         """
         Create representation sendable via POST from form data
 
-        :param v: value to prepare
-        :type v: any
+        Needed to automatically check create, update and delete views
+
+        :param val: value to prepare
+        :type val: any
         :return: prepared value (normally either raw value or primary key of complex object)
         """
-        if type(v) == list:
-            return [e.pk for e in v]
-        if type(v) == "RelatedManager":
-            return [e.pk for e in v.all()]
-        return v
+        if isinstance(val, list):
+            return [e.pk for e in val]
+        if type(val) == "RelatedManager":  # pylint: disable=unidiomatic-typecheck
+            return [e.pk for e in val.all()]
+        return val
 
     def test_submit_edit_form(self):
         """
-        Test edit forms in the most simple way (sending them again unchanged)
+        Test edit forms (as specified in "EDIT_TESTCASES") in the most simple way (sending them again unchanged)
         """
         for testcase in self.EDIT_TESTCASES:
             self._test_submit_edit_form(testcase)
 
     def _test_submit_edit_form(self, testcase):
+        """
+        Test a single edit form by rendering and sending it again unchanged
+
+        This will test for correct rendering, dispatching/redirecting, messages and access control handling
+
+        :param testcase: details of the form to test
+        """
         name, url = self._name_and_url((testcase["view"], testcase["kwargs"]))
         form_name = testcase.get("form_name", "form")
         expected_code = testcase.get("expected_code", 302)
@@ -130,79 +227,137 @@ class BasicViewTests:
             self.client.logout()
 
         response = self.client.get(url)
-        self.assertEqual(response.status_code, 200, msg=f"{name}: Could not load edit form via GET ({url})")
+        self.assertEqual(
+            response.status_code,
+            200,
+            msg=f"{name}: Could not load edit form via GET ({url})",
+        )
 
         form = response.context[form_name]
-        data = {k:self._to_sendable_value(v) for k,v in form.initial.items()}
+        data = {k: self._to_sendable_value(v) for k, v in form.initial.items()}
 
         response = self.client.post(url, data=data)
         if expected_code == 200:
-            self.assertEqual(response.status_code, 200, msg=f"{name}: Did not return 200 ({url}")
+            self.assertEqual(
+                response.status_code, 200, msg=f"{name}: Did not return 200 ({url}"
+            )
         elif expected_code == 302:
-            self.assertRedirects(response, target_url, msg_prefix=f"{name}: Did not redirect ({url} -> {target_url}")
+            self.assertRedirects(
+                response,
+                target_url,
+                msg_prefix=f"{name}: Did not redirect ({url} -> {target_url}",
+            )
         if expected_message != "":
             self._assert_message(response, expected_message, msg_prefix=f"{name}")
 
 
 class ModelViewTests(BasicViewTests, TestCase):
-    fixtures = ['model.json']
+    """
+    Basic view test cases for views from AKModel plus some custom tests
+    """
+
+    fixtures = ["model.json"]
 
     ADMIN_MODELS = [
-        (Event, 'event'), (AKOwner, 'akowner'), (AKCategory, 'akcategory'), (AKTrack, 'aktrack'),
-        (AKRequirement, 'akrequirement'), (AK, 'ak'), (Room, 'room'), (AKSlot, 'akslot'),
-        (AKOrgaMessage, 'akorgamessage'), (ConstraintViolation, 'constraintviolation'),
-        (DefaultSlot, 'defaultslot')
+        (Event, "event"),
+        (AKOwner, "akowner"),
+        (AKCategory, "akcategory"),
+        (AKTrack, "aktrack"),
+        (AKRequirement, "akrequirement"),
+        (AK, "ak"),
+        (Room, "room"),
+        (AKSlot, "akslot"),
+        (AKOrgaMessage, "akorgamessage"),
+        (ConstraintViolation, "constraintviolation"),
+        (DefaultSlot, "defaultslot"),
     ]
 
     VIEWS_STAFF_ONLY = [
-        ('admin:index', {}),
-        ('admin:event_status', {'slug': 'kif42'}),
-        ('admin:event_requirement_overview', {'event_slug': 'kif42'}),
-        ('admin:ak_csv_export', {'event_slug': 'kif42'}),
-        ('admin:ak_wiki_export', {'slug': 'kif42'}),
-        ('admin:ak_delete_orga_messages', {'event_slug': 'kif42'}),
-        ('admin:ak_slide_export', {'event_slug': 'kif42'}),
-        ('admin:default-slots-editor', {'event_slug': 'kif42'}),
-        ('admin:room-import', {'event_slug': 'kif42'}),
-        ('admin:new_event_wizard_start', {}),
+        ("admin:index", {}),
+        ("admin:event_status", {"event_slug": "kif42"}),
+        ("admin:event_requirement_overview", {"event_slug": "kif42"}),
+        ("admin:ak_csv_export", {"event_slug": "kif42"}),
+        ("admin:ak_json_export", {"event_slug": "kif42"}),
+        ("admin:ak_wiki_export", {"slug": "kif42"}),
+        ("admin:ak_schedule_json_import", {"event_slug": "kif42"}),
+        ("admin:ak_delete_orga_messages", {"event_slug": "kif42"}),
+        ("admin:ak_slide_export", {"event_slug": "kif42"}),
+        ("admin:default-slots-editor", {"event_slug": "kif42"}),
+        ("admin:room-import", {"event_slug": "kif42"}),
+        ("admin:new_event_wizard_start", {}),
     ]
 
     EDIT_TESTCASES = [
-        {'view': 'admin:default-slots-editor', 'kwargs': {'event_slug': 'kif42'}, "admin": True},
+        {
+            "view": "admin:default-slots-editor",
+            "kwargs": {"event_slug": "kif42"},
+            "admin": True,
+        },
     ]
 
     def test_admin(self):
+        """
+        Test basic admin functionality (displaying and interacting with model instances)
+        """
         self.client.force_login(self.admin_user)
         for model in self.ADMIN_MODELS:
+            # Special treatment for a subset of views (where we exchanged default functionality, e.g., create views)
             if model[1] == "event":
-                view_name_with_prefix, url = self._name_and_url((f'admin:new_event_wizard_start', {}))
+                _, url = self._name_and_url(("admin:new_event_wizard_start", {}))
             elif model[1] == "room":
-                view_name_with_prefix, url = self._name_and_url((f'admin:room-new', {}))
+                _, url = self._name_and_url(("admin:room-new", {}))
+            # Otherwise, just call the creation form view
             else:
-                view_name_with_prefix, url = self._name_and_url((f'admin:AKModel_{model[1]}_add', {}))
+                _, url = self._name_and_url((f"admin:AKModel_{model[1]}_add", {}))
             response = self.client.get(url)
-            self.assertEqual(response.status_code, 200, msg=f"Add form for model {model[1]} ({url}) broken")
+            self.assertEqual(
+                response.status_code,
+                200,
+                msg=f"Add form for model {model[1]} ({url}) broken",
+            )
 
         for model in self.ADMIN_MODELS:
+            # Test the update view using the first existing instance of each model
             m = model[0].objects.first()
             if m is not None:
-                view_name_with_prefix, url = self._name_and_url((f'admin:AKModel_{model[1]}_change', {'object_id': m.pk}))
+                _, url = self._name_and_url(
+                    (f"admin:AKModel_{model[1]}_change", {"object_id": m.pk})
+                )
                 response = self.client.get(url)
-                self.assertEqual(response.status_code, 200, msg=f"Edit form for model {model[1]} ({url}) broken")
+                self.assertEqual(
+                    response.status_code,
+                    200,
+                    msg=f"Edit form for model {model[1]} ({url}) broken",
+                )
 
     def test_wiki_export(self):
+        """
+        Test wiki export
+        This will test whether the view renders at all and whether the export list contains the correct AKs
+        """
         self.client.force_login(self.admin_user)
 
-        export_url = reverse_lazy(f"admin:ak_wiki_export", kwargs={'slug': 'kif42'})
+        export_url = reverse_lazy("admin:ak_wiki_export", kwargs={"slug": "kif42"})
         response = self.client.get(export_url)
         self.assertEqual(response.status_code, 200, "Export not working at all")
 
         export_count = 0
-        for category, aks in response.context["categories_with_aks"]:
+        for _, aks in response.context["categories_with_aks"]:
             for ak in aks:
-                self.assertEqual(ak.include_in_export, True, f"AK with export flag set to False (pk={ak.pk}) included in export")
-                self.assertNotEqual(ak.pk, 1, "AK known to be excluded from export (PK 1) included in export")
+                self.assertEqual(
+                    ak.include_in_export,
+                    True,
+                    f"AK with export flag set to False (pk={ak.pk}) included in export",
+                )
+                self.assertNotEqual(
+                    ak.pk,
+                    1,
+                    "AK known to be excluded from export (PK 1) included in export",
+                )
                 export_count += 1
 
-        self.assertEqual(export_count, AK.objects.filter(event_id=2, include_in_export=True).count(),
-                         "Wiki export contained the wrong number of AKs")
+        self.assertEqual(
+            export_count,
+            AK.objects.filter(event_id=2, include_in_export=True).count(),
+            "Wiki export contained the wrong number of AKs",
+        )

AKModel/urls.py

@@ -3,20 +3,28 @@ from django.apps import apps
 from django.urls import include, path
 from rest_framework.routers import DefaultRouter
 
-from AKModel import views
-from AKModel.views import NewEventWizardStartView, NewEventWizardSettingsView, NewEventWizardPrepareImportView, \
-    NewEventWizardImportView, NewEventWizardActivateView, NewEventWizardFinishView, EventStatusView, \
-    AKRequirementOverview, AKCSVExportView, AKWikiExportView, AKMessageDeleteView, ExportSlidesView
+import AKModel.views.api
+from AKModel.views.manage import ExportSlidesView, PlanPublishView, PlanUnpublishView, DefaultSlotEditorView, \
+    AKsByUserView, AKScheduleJSONImportView
+from AKModel.views.ak import AKRequirementOverview, AKCSVExportView, AKJSONExportView, AKWikiExportView, \
+     AKMessageDeleteView
+from AKModel.views.event_wizard import NewEventWizardStartView, NewEventWizardPrepareImportView, \
+    NewEventWizardImportView, NewEventWizardActivateView, NewEventWizardFinishView, NewEventWizardSettingsView
+from AKModel.views.room import RoomBatchCreationView
+from AKModel.views.status import EventStatusView
 
+# Register basic API views/endpoints
 api_router = DefaultRouter()
-api_router.register('akowner', views.AKOwnerViewSet, basename='AKOwner')
-api_router.register('akcategory', views.AKCategoryViewSet, basename='AKCategory')
-api_router.register('aktrack', views.AKTrackViewSet, basename='AKTrack')
-api_router.register('ak', views.AKViewSet, basename='AK')
-api_router.register('room', views.RoomViewSet, basename='Room')
-api_router.register('akslot', views.AKSlotViewSet, basename='AKSlot')
+api_router.register('akowner', AKModel.views.api.AKOwnerViewSet, basename='AKOwner')
+api_router.register('akcategory', AKModel.views.api.AKCategoryViewSet, basename='AKCategory')
+api_router.register('aktrack', AKModel.views.api.AKTrackViewSet, basename='AKTrack')
+api_router.register('ak', AKModel.views.api.AKViewSet, basename='AK')
+api_router.register('room', AKModel.views.api.RoomViewSet, basename='Room')
+api_router.register('akslot', AKModel.views.api.AKSlotViewSet, basename='AKSlot')
 
+# TODO Can we move this functionality to the individual apps instead?
 extra_paths = []
+# If AKScheduling is active, register additional API endpoints
 if apps.is_installed("AKScheduling"):
     from AKScheduling.api import ResourcesViewSet, RoomAvailabilitiesView, EventsView, EventsViewSet, \
         ConstraintViolationsViewSet, DefaultSlotsView
@@ -31,9 +39,10 @@ if apps.is_installed("AKScheduling"):
              name='scheduling-room-availabilities')),
     extra_paths.append(path('api/scheduling-default-slots/', DefaultSlotsView.as_view(),
              name='scheduling-default-slots'))
+
+#If AKSubmission is active, register an additional API endpoint for increasing the interest counter
 if apps.is_installed("AKSubmission"):
     from AKSubmission.api import increment_interest_counter
-
     extra_paths.append(path('api/ak/<pk>/indicate-interest/', increment_interest_counter, name='submission-ak-indicate-interest'))
 
 event_specific_paths = [
@@ -43,16 +52,20 @@ event_specific_paths.extend(extra_paths)
 
 app_name = 'model'
 
+# Included all these extra view paths at a path starting with the event slug
 urlpatterns = [
     path(
         '<slug:event_slug>/',
         include(event_specific_paths)
     ),
-    path('user/', views.UserView.as_view(), name="user"),
+    path('user/', AKModel.views.manage.UserView.as_view(), name="user"),
 ]
 
 
 def get_admin_urls_event_wizard(admin_site):
+    """
+    Defines all additional URLs for the event creation wizard
+    """
     return [
         path('add/wizard/start/', admin_site.admin_view(NewEventWizardStartView.as_view()),
              name="new_event_wizard_start"),
@@ -73,15 +86,30 @@ def get_admin_urls_event_wizard(admin_site):
 
 
 def get_admin_urls_event(admin_site):
+    """
+    Defines all additional event-related view URLs that will be included in the event admin interface
+    """
     return [
-        path('<slug:slug>/status/', admin_site.admin_view(EventStatusView.as_view()), name="event_status"),
+        path('<slug:event_slug>/status/', admin_site.admin_view(EventStatusView.as_view()), name="event_status"),
         path('<slug:event_slug>/requirements/', admin_site.admin_view(AKRequirementOverview.as_view()),
              name="event_requirement_overview"),
+        path('<slug:event_slug>/aks/owner/<pk>/', admin_site.admin_view(AKsByUserView.as_view()),
+             name="aks_by_owner"),
         path('<slug:event_slug>/ak-csv-export/', admin_site.admin_view(AKCSVExportView.as_view()),
              name="ak_csv_export"),
+        path('<slug:event_slug>/ak-json-export/', admin_site.admin_view(AKJSONExportView.as_view()),
+             name="ak_json_export"),
+        path('<slug:event_slug>/ak-schedule-json-import/', admin_site.admin_view(AKScheduleJSONImportView.as_view()),
+             name="ak_schedule_json_import"),
         path('<slug:slug>/ak-wiki-export/', admin_site.admin_view(AKWikiExportView.as_view()),
              name="ak_wiki_export"),
         path('<slug:event_slug>/delete-orga-messages/', admin_site.admin_view(AKMessageDeleteView.as_view()),
              name="ak_delete_orga_messages"),
         path('<slug:event_slug>/ak-slide-export/', admin_site.admin_view(ExportSlidesView.as_view()), name="ak_slide_export"),
+        path('plan/publish/', admin_site.admin_view(PlanPublishView.as_view()), name="plan-publish"),
+        path('plan/unpublish/', admin_site.admin_view(PlanUnpublishView.as_view()), name="plan-unpublish"),
+        path('<slug:event_slug>/defaultSlots/', admin_site.admin_view(DefaultSlotEditorView.as_view()),
+             name="default-slots-editor"),
+        path('<slug:event_slug>/importRooms/', admin_site.admin_view(RoomBatchCreationView.as_view()),
+             name="room-import"),
     ]

AKModel/utils.py

+from pathlib import Path
+
+import referencing.retrieval
+from jsonschema import Draft202012Validator
+from jsonschema.protocols import Validator
+from referencing import Registry
+
+from AKPlanning import settings
+
+
+def _construct_schema_path(uri: str | Path) -> Path:
+    """Construct a schema URI.
+
+    This function also checks for unallowed directory traversals
+    out of the 'schema' subfolder.
+    """
+    schema_base_path = Path(settings.BASE_DIR).resolve()
+    uri_path = (schema_base_path / uri).resolve()
+    if not uri_path.is_relative_to(schema_base_path / "schemas"):
+        raise ValueError("Unallowed dictionary traversal")
+    return uri_path
+
+
+@referencing.retrieval.to_cached_resource()
+def retrieve_schema_from_disk(uri: str) -> str:
+    """Retrieve schemas from disk by URI."""
+    uri_path = _construct_schema_path(uri)
+    with uri_path.open("r") as ff:
+        return ff.read()
+
+
+def construct_schema_validator(schema: str | dict) -> Validator:
+    """Construct a validator for a JSON schema.
+
+    In particular, all schemas from the 'schemas' directory
+    are loaded into the registry.
+    """
+    registry = Registry(retrieve=retrieve_schema_from_disk)
+
+    if isinstance(schema, str):
+        schema_uri = str(Path("schemas") / schema)
+        schema = registry.get_or_retrieve(schema_uri).value.contents
+    return Draft202012Validator(schema=schema, registry=registry)

AKModel/views.py

-import csv
-import datetime
-import json
-import os
-import tempfile
-from abc import ABC, abstractmethod
-from itertools import zip_longest
-
-import django.db
-from django.apps import apps
-from django.contrib import admin, messages
-from django.db.models.functions import Now
-from django.http import HttpResponseRedirect
-from django.shortcuts import get_object_or_404, redirect
-from django.urls import reverse_lazy, reverse
-from django.utils.dateparse import parse_datetime
-from django.utils.translation import gettext_lazy as _
-from django.views.generic import TemplateView, DetailView, ListView, DeleteView, CreateView, FormView, UpdateView
-from django_tex.core import render_template_with_context, run_tex_in_directory
-from django_tex.response import PDFResponse
-from rest_framework import viewsets, permissions, mixins
-
-from AKModel.forms import NewEventWizardStartForm, NewEventWizardSettingsForm, NewEventWizardPrepareImportForm, \
-    NewEventWizardImportForm, NewEventWizardActivateForm, AdminIntermediateForm, SlideExportForm, \
-    AdminIntermediateActionForm, DefaultSlotEditorForm, RoomBatchCreationForm, RoomForm
-from AKModel.models import Event, AK, AKSlot, Room, AKTrack, AKCategory, AKOwner, AKOrgaMessage, AKRequirement, \
-    ConstraintViolation, DefaultSlot
-from AKModel.serializers import AKSerializer, AKSlotSerializer, RoomSerializer, AKTrackSerializer, AKCategorySerializer, \
-    AKOwnerSerializer
-
-
-class EventSlugMixin:
-    """
-    Mixin to handle views with event slugs
-    """
-    event = None
-
-    def _load_event(self):
-        # Find event based on event slug
-        if self.event is None:
-            self.event = get_object_or_404(Event, slug=self.kwargs.get("event_slug", None))
-
-    def get(self, request, *args, **kwargs):
-        self._load_event()
-        return super().get(request, *args, **kwargs)
-
-    def post(self, request, *args, **kwargs):
-        self._load_event()
-        return super().post(request, *args, **kwargs)
-
-    def list(self, request, *args, **kwargs):
-        self._load_event()
-        return super().list(request, *args, **kwargs)
-
-    def create(self, request, *args, **kwargs):
-        self._load_event()
-        return super().create(request, *args, **kwargs)
-
-    def dispatch(self, request, *args, **kwargs):
-        if self.event is None:
-            self._load_event()
-        return super().dispatch(request, *args, **kwargs)
-
-    def get_context_data(self, *, object_list=None, **kwargs):
-        context = super().get_context_data(object_list=object_list, **kwargs)
-        # Add event to context (to make it accessible in templates)
-        context["event"] = self.event
-        return context
-
-
-class FilterByEventSlugMixin(EventSlugMixin):
-    """
-    Mixin to filter different querysets based on a event slug from the request url
-    """
-
-    def get_queryset(self):
-        # Filter current queryset based on url event slug or return 404 if event slug is invalid
-        return super().get_queryset().filter(event=self.event)
-
-
-class AdminViewMixin:
-    site_url = ''
-    title = ''
-
-    def get_context_data(self, **kwargs):
-        extra = admin.site.each_context(self.request)
-        extra.update(super().get_context_data(**kwargs))
-
-        if self.site_url != '':
-            extra["site_url"] = self.site_url
-        if self.title != '':
-            extra["title"] = self.title
-
-        return extra
-
-
-class AKOwnerViewSet(EventSlugMixin, mixins.RetrieveModelMixin, mixins.ListModelMixin, viewsets.GenericViewSet):
-    permission_classes = (permissions.DjangoModelPermissionsOrAnonReadOnly,)
-    serializer_class = AKOwnerSerializer
-
-    def get_queryset(self):
-        return AKOwner.objects.filter(event=self.event)
-
-
-class AKCategoryViewSet(EventSlugMixin, mixins.RetrieveModelMixin, mixins.ListModelMixin, viewsets.GenericViewSet):
-    permission_classes = (permissions.DjangoModelPermissionsOrAnonReadOnly,)
-    serializer_class = AKCategorySerializer
-
-    def get_queryset(self):
-        return AKCategory.objects.filter(event=self.event)
-
-
-class AKTrackViewSet(EventSlugMixin, mixins.RetrieveModelMixin, mixins.CreateModelMixin, mixins.UpdateModelMixin,
-                     mixins.DestroyModelMixin, mixins.ListModelMixin, viewsets.GenericViewSet):
-    permission_classes = (permissions.DjangoModelPermissionsOrAnonReadOnly,)
-    serializer_class = AKTrackSerializer
-
-    def get_queryset(self):
-        return AKTrack.objects.filter(event=self.event)
-
-
-class AKViewSet(EventSlugMixin, mixins.RetrieveModelMixin, mixins.UpdateModelMixin, mixins.ListModelMixin,
-                viewsets.GenericViewSet):
-    permission_classes = (permissions.DjangoModelPermissionsOrAnonReadOnly,)
-    serializer_class = AKSerializer
-
-    def get_queryset(self):
-        return AK.objects.filter(event=self.event)
-
-
-class RoomViewSet(EventSlugMixin, mixins.RetrieveModelMixin, mixins.ListModelMixin, viewsets.GenericViewSet):
-    permission_classes = (permissions.DjangoModelPermissionsOrAnonReadOnly,)
-    serializer_class = RoomSerializer
-
-    def get_queryset(self):
-        return Room.objects.filter(event=self.event)
-
-
-class AKSlotViewSet(EventSlugMixin, mixins.RetrieveModelMixin, mixins.CreateModelMixin, mixins.UpdateModelMixin,
-                    mixins.ListModelMixin, viewsets.GenericViewSet):
-    permission_classes = (permissions.DjangoModelPermissionsOrAnonReadOnly,)
-    serializer_class = AKSlotSerializer
-
-    def get_queryset(self):
-        return AKSlot.objects.filter(event=self.event)
-
-
-class UserView(TemplateView):
-    template_name = "AKModel/user.html"
-
-
-class EventStatusView(AdminViewMixin, DetailView):
-    template_name = "admin/AKModel/status.html"
-    model = Event
-    context_object_name = "event"
-    title = _("Event Status")
-
-    def get_context_data(self, **kwargs):
-        context = super().get_context_data(**kwargs)
-        context["unscheduled_slots_count"] = context["event"].akslot_set.filter(start=None).count
-        context["site_url"] = reverse_lazy("dashboard:dashboard_event", kwargs={'slug': context["event"].slug})
-        context["ak_messages"] = AKOrgaMessage.objects.filter(ak__event=context["event"])
-        return context
-
-
-class AKRequirementOverview(AdminViewMixin, FilterByEventSlugMixin, ListView):
-    model = AKRequirement
-    context_object_name = "requirements"
-    title = _("Requirements for Event")
-    template_name = "admin/AKModel/requirements_overview.html"
-
-    def get_context_data(self, **kwargs):
-        context = super().get_context_data(**kwargs)
-        context["event"] = self.event
-        context["site_url"] = reverse_lazy("dashboard:dashboard_event", kwargs={'slug': context["event"].slug})
-        return context
-
-
-class AKCSVExportView(AdminViewMixin, FilterByEventSlugMixin, ListView):
-    template_name = "admin/AKModel/ak_csv_export.html"
-    model = AKSlot
-    context_object_name = "slots"
-    title = _("AK CSV Export")
-
-    def get_queryset(self):
-        return super().get_queryset().order_by("ak__track")
-
-    def get_context_data(self, **kwargs):
-        context = super().get_context_data(**kwargs)
-        return context
-
-
-class AKWikiExportView(AdminViewMixin, DetailView):
-    template_name = "admin/AKModel/wiki_export.html"
-    model = Event
-    context_object_name = "event"
-    title = _("AK Wiki Export")
-
-    def get_context_data(self, **kwargs):
-        context = super().get_context_data(**kwargs)
-
-        categories_with_aks, ak_wishes = context["event"].get_categories_with_aks(
-            wishes_seperately=True,
-            filter=lambda ak: ak.include_in_export
-        )
-
-        context["categories_with_aks"] = [(category.name, ak_list) for category, ak_list in categories_with_aks]
-        context["categories_with_aks"].append((_("Wishes"), ak_wishes))
-
-        return context
-
-
-class IntermediateAdminView(AdminViewMixin, FormView):
-    template_name = "admin/AKModel/action_intermediate.html"
-    form_class = AdminIntermediateForm
-
-    def get_preview(self):
-        return ""
-
-    def get_context_data(self, **kwargs):
-        context = super().get_context_data(**kwargs)
-        context["title"] = self.title
-        context["preview"] = self.get_preview()
-        return context
-
-
-class AKMessageDeleteView(EventSlugMixin, IntermediateAdminView):
-    template_name = "admin/AKModel/message_delete.html"
-    title = _("Delete AK Orga Messages")
-
-    def get_orga_messages_for_event(self, event):
-        return AKOrgaMessage.objects.filter(ak__event=event)
-
-    def get_success_url(self):
-        return reverse_lazy('admin:event_status', kwargs={'slug': self.event.slug})
-
-    def get_context_data(self, **kwargs):
-        context = super().get_context_data(**kwargs)
-        context["ak_messages"] = self.get_orga_messages_for_event(self.event)
-        return context
-
-    def form_valid(self, form):
-        self.get_orga_messages_for_event(self.event).delete()
-        messages.add_message(self.request, messages.SUCCESS, _("AK Orga Messages successfully deleted"))
-        return super().form_valid(form)
-
-
-class WizardViewMixin:
-    def get_context_data(self, **kwargs):
-        context = super().get_context_data(**kwargs)
-        context["wizard_step"] = self.wizard_step
-        context["wizard_steps"] = [
-            _("Start"),
-            _("Settings"),
-            _("Event created, Prepare Import"),
-            _("Import categories & requirements"),
-            _("Activate?"),
-            _("Finish")
-        ]
-        context["wizard_step_text"] = context["wizard_steps"][self.wizard_step - 1]
-        context["wizard_steps_total"] = len(context["wizard_steps"])
-        return context
-
-
-class NewEventWizardStartView(AdminViewMixin, WizardViewMixin, CreateView):
-    model = Event
-    form_class = NewEventWizardStartForm
-    template_name = "admin/AKModel/event_wizard/start.html"
-    wizard_step = 1
-
-
-class NewEventWizardSettingsView(AdminViewMixin, WizardViewMixin, CreateView):
-    model = Event
-    form_class = NewEventWizardSettingsForm
-    template_name = "admin/AKModel/event_wizard/settings.html"
-    wizard_step = 2
-
-    def get_context_data(self, **kwargs):
-        context = super().get_context_data(**kwargs)
-        context["timezone"] = context["form"].cleaned_data["timezone"]
-        return context
-
-    def get_success_url(self):
-        return reverse_lazy("admin:new_event_wizard_prepare_import", kwargs={"event_slug": self.object.slug})
-
-
-class NewEventWizardPrepareImportView(WizardViewMixin, EventSlugMixin, FormView):
-    form_class = NewEventWizardPrepareImportForm
-    template_name = "admin/AKModel/event_wizard/created_prepare_import.html"
-    wizard_step = 3
-
-    def form_valid(self, form):
-        # Selected a valid event to import from? Use this to go to next step of wizard
-        return redirect("admin:new_event_wizard_import", event_slug=self.event.slug,
-                        import_slug=form.cleaned_data["import_event"].slug)
-
-
-class NewEventWizardImportView(EventSlugMixin, WizardViewMixin, FormView):
-    form_class = NewEventWizardImportForm
-    template_name = "admin/AKModel/event_wizard/import.html"
-    wizard_step = 4
-
-    def get_initial(self):
-        initial = super().get_initial()
-        initial["import_event"] = Event.objects.get(slug=self.kwargs["import_slug"])
-        return initial
-
-    def form_valid(self, form):
-        import_types = ["import_categories", "import_requirements"]
-        if apps.is_installed("AKDashboard"):
-            import_types.append("import_buttons")
-
-        for import_type in import_types:
-            for import_obj in form.cleaned_data.get(import_type):
-                # clone existing entry
-                try:
-                    import_obj.event = self.event
-                    import_obj.pk = None
-                    import_obj.save()
-                    messages.add_message(self.request, messages.SUCCESS, _("Copied '%(obj)s'" % {'obj': import_obj}))
-                except BaseException as e:
-                    messages.add_message(self.request, messages.ERROR,
-                                         _("Could not copy '%(obj)s' (%(error)s)" % {'obj': import_obj,
-                                                                                     "error": str(e)}))
-        return redirect("admin:new_event_wizard_activate", slug=self.event.slug)
-
-
-class NewEventWizardActivateView(WizardViewMixin, UpdateView):
-    model = Event
-    template_name = "admin/AKModel/event_wizard/activate.html"
-    form_class = NewEventWizardActivateForm
-    wizard_step = 5
-
-    def get_success_url(self):
-        return reverse_lazy("admin:new_event_wizard_finish", kwargs={"slug": self.object.slug})
-
-
-class NewEventWizardFinishView(WizardViewMixin, DetailView):
-    model = Event
-    template_name = "admin/AKModel/event_wizard/finish.html"
-    wizard_step = 6
-
-
-class ExportSlidesView(EventSlugMixin, IntermediateAdminView):
-    title = _('Export AK Slides')
-    form_class = SlideExportForm
-
-    def form_valid(self, form):
-        template_name = 'admin/AKModel/export/slides.tex'
-
-        NEXT_AK_LIST_LENGTH = form.cleaned_data['num_next']
-        RESULT_PRESENTATION_MODE = form.cleaned_data["presentation_mode"]
-        SPACE_FOR_NOTES_IN_WISHES = form.cleaned_data["wish_notes"]
-
-        translations = {
-            'symbols': _("Symbols"),
-            'who': _("Who?"),
-            'duration': _("Duration(s)"),
-            'reso': _("Reso intention?"),
-            'category': _("Category (for Wishes)"),
-            'wishes': _("Wishes"),
-        }
-
-        def build_ak_list_with_next_aks(ak_list):
-            next_aks_list = zip_longest(*[ak_list[i + 1:] for i in range(NEXT_AK_LIST_LENGTH)], fillvalue=None)
-            return [(ak, next_aks) for ak, next_aks in zip_longest(ak_list, next_aks_list, fillvalue=list())]
-
-        categories_with_aks, ak_wishes = self.event.get_categories_with_aks(wishes_seperately=True, filter=lambda
-            ak: not RESULT_PRESENTATION_MODE or (ak.present or (ak.present is None and ak.category.present_by_default)))
-
-        context = {
-            'title': self.event.name,
-            'categories_with_aks': [(category, build_ak_list_with_next_aks(ak_list)) for category, ak_list in
-                                    categories_with_aks],
-            'subtitle': _("AKs"),
-            "wishes": build_ak_list_with_next_aks(ak_wishes),
-            "translations": translations,
-            "result_presentation_mode": RESULT_PRESENTATION_MODE,
-            "space_for_notes_in_wishes": SPACE_FOR_NOTES_IN_WISHES,
-        }
-
-        source = render_template_with_context(template_name, context)
-
-        # Perform real compilation (run latex twice for correct page numbers)
-        with tempfile.TemporaryDirectory() as tempdir:
-            run_tex_in_directory(source, tempdir, template_name=self.template_name)
-            os.remove(f'{tempdir}/texput.tex')
-            pdf = run_tex_in_directory(source, tempdir, template_name=self.template_name)
-
-        timestamp = datetime.datetime.now(tz=self.event.timezone).strftime("%Y-%m-%d_%H_%M")
-        return PDFResponse(pdf, filename=f'{self.event.slug}_ak_slides_{timestamp}.pdf')
-
-
-class IntermediateAdminActionView(IntermediateAdminView, ABC):
-    form_class = AdminIntermediateActionForm
-    entities = None
-
-    def get_queryset(self, pks=None):
-        if pks is None:
-            pks = self.request.GET['pks']
-        return self.model.objects.filter(pk__in=pks.split(","))
-
-    def get_initial(self):
-        initial = super().get_initial()
-        initial['pks'] = self.request.GET['pks']
-        return initial
-
-    def get_preview(self):
-        self.entities = self.get_queryset()
-        joined_entities = '\n'.join(str(e) for e in self.entities)
-        return f"{self.confirmation_message}:\n\n {joined_entities}"
-
-    def get_success_url(self):
-        return reverse(f"admin:{self.model._meta.app_label}_{self.model._meta.model_name}_changelist")
-
-    @abstractmethod
-    def action(self, form):
-        pass
-
-    def form_valid(self, form):
-        self.entities = self.get_queryset(pks=form.cleaned_data['pks'])
-        self.action(form)
-        messages.add_message(self.request, messages.SUCCESS, self.success_message)
-        return super().form_valid(form)
-
-
-class LoopActionMixin(ABC):
-    def action(self, form):
-        self.pre_action()
-        for entity in self.entities:
-            self.perform_action(entity)
-            entity.save()
-        self.post_action()
-
-    @abstractmethod
-    def perform_action(self, entity):
-        pass
-
-    def pre_action(self):
-        pass
-
-    def post_action(self):
-        pass
-
-
-class CVMarkResolvedView(IntermediateAdminActionView):
-    title = _('Mark Constraint Violations as manually resolved')
-    model = ConstraintViolation
-    confirmation_message = _("The following Constraint Violations will be marked as manually resolved")
-    success_message = _("Constraint Violations marked as resolved")
-
-    def action(self, form):
-        self.entities.update(manually_resolved=True)
-
-
-class CVSetLevelViolationView(IntermediateAdminActionView):
-    title = _('Set Constraint Violations to level "violation"')
-    model = ConstraintViolation
-    confirmation_message = _("The following Constraint Violations will be set to level 'violation'")
-    success_message = _("Constraint Violations set to level 'violation'")
-
-    def action(self, form):
-        self.entities.update(level=ConstraintViolation.ViolationLevel.VIOLATION)
-
-
-class CVSetLevelWarningView(IntermediateAdminActionView):
-    title = _('Set Constraint Violations to level "warning"')
-    model = ConstraintViolation
-    confirmation_message = _("The following Constraint Violations will be set to level 'warning'")
-    success_message = _("Constraint Violations set to level 'warning'")
-
-    def action(self, form):
-        self.entities.update(level=ConstraintViolation.ViolationLevel.WARNING)
-
-
-class AKResetInterestView(IntermediateAdminActionView):
-    title = _("Reset interest in AKs")
-    model = AK
-    confirmation_message = _("Interest of the following AKs will be set to not filled (-1):")
-    success_message = _("Reset of interest in AKs successful.")
-
-    def action(self, form):
-        self.entities.update(interest=-1)
-
-
-class AKResetInterestCounterView(IntermediateAdminActionView):
-    title = _("Reset AKs' interest counters")
-    model = AK
-    confirmation_message = _("Interest counter of the following AKs will be set to 0:")
-    success_message = _("AKs' interest counters set back to 0.")
-
-    def action(self, form):
-        self.entities.update(interest_counter=0)
-
-
-class PlanPublishView(IntermediateAdminActionView):
-    title = _('Publish plan')
-    model = Event
-    confirmation_message = _('Publish the plan(s) of:')
-    success_message = _('Plan published')
-
-    def action(self, form):
-        self.entities.update(plan_published_at=Now(), plan_hidden=False)
-
-
-class PlanUnpublishView(IntermediateAdminActionView):
-    title = _('Unpublish plan')
-    model = Event
-    confirmation_message = _('Unpublish the plan(s) of:')
-    success_message = _('Plan unpublished')
-
-    def action(self, form):
-        self.entities.update(plan_published_at=None, plan_hidden=True)
-
-
-class DefaultSlotEditorView(EventSlugMixin, IntermediateAdminView):
-    template_name = "admin/AKModel/default_slot_editor.html"
-    form_class = DefaultSlotEditorForm
-    title = _("Edit Default Slots")
-
-    def get_success_url(self):
-        return self.request.path
-
-    def get_initial(self):
-        initial = super().get_initial()
-        default_slots = [
-            {"id": s.id, "start": s.start_iso, "end": s.end_iso, "allDay": False}
-            for s in self.event.defaultslot_set.all()
-        ]
-        initial['availabilities'] = json.dumps({
-            'availabilities': default_slots
-        })
-        return initial
-
-    def form_valid(self, form):
-        default_slots_raw = json.loads(form.cleaned_data['availabilities'])["availabilities"]
-        tz = self.event.timezone
-
-        created_count = 0
-        updated_count = 0
-
-        previous_slot_ids = set(s.id for s in self.event.defaultslot_set.all())
-
-        for slot in default_slots_raw:
-            start = parse_datetime(slot["start"]).astimezone(tz)
-            end = parse_datetime(slot["end"]).astimezone(tz)
-
-            if slot["id"] != '':
-                id = int(slot["id"])
-                if id not in previous_slot_ids:
-                    # Make sure only slots (currently) belonging to this event are edited
-                    # (user did not manipulate IDs and slots have not been deleted in another session in the meantime)
-                    messages.add_message(
-                        self.request,
-                        messages.WARNING,
-                        _("Could not update slot {id} since it does not belong to {event}")
-                        .format(id=slot['id'], event=self.event.name)
-                    )
-                else:
-                    # Update existing entries
-                    previous_slot_ids.remove(id)
-                    original_slot = DefaultSlot.objects.get(id=id)
-                    if original_slot.start != start or original_slot.end != end:
-                        original_slot.start = start
-                        original_slot.end = end
-                        original_slot.save()
-                        updated_count += 1
-            else:
-                # Create new entries
-                DefaultSlot.objects.create(
-                    start=start,
-                    end=end,
-                    event=self.event
-                )
-                created_count += 1
-
-        # Delete all slots not re-submitted by the user (and hence deleted in editor)
-        deleted_count = len(previous_slot_ids)
-        for d_id in previous_slot_ids:
-            DefaultSlot.objects.get(id=d_id).delete()
-
-        if created_count + updated_count + deleted_count > 0:
-            messages.add_message(
-                self.request,
-                messages.SUCCESS,
-                _("Updated {u} slot(s). created {c} new slot(s) and deleted {d} slot(s)")
-                .format(u=str(updated_count), c=str(created_count), d=str(deleted_count))
-            )
-        return super().form_valid(form)
-
-
-class RoomCreationView(AdminViewMixin, CreateView):
-    form_class = RoomForm
-    template_name = 'admin/AKModel/room_create.html'
-
-    def get_success_url(self):
-        print(self.request.POST['save_action'])
-        if self.request.POST['save_action'] == 'save_add_another':
-            return reverse_lazy('admin:room-new')
-        elif self.request.POST['save_action'] == 'save_continue':
-            return reverse_lazy('admin:AKModel_room_change', kwargs={'object_id': self.room.pk})
-        else:
-            return reverse_lazy('admin:AKModel_room_changelist')
-
-    def form_valid(self, form):
-        self.room = form.save()
-        messages.success(self.request, _("Created Room '%(room)s'" % {'room': self.room}))
-        return HttpResponseRedirect(self.get_success_url())
-
-
-class RoomBatchCreationView(EventSlugMixin, IntermediateAdminView):
-    form_class = RoomBatchCreationForm
-    title = _("Import Rooms from CSV")
-
-    def get_success_url(self):
-        return reverse_lazy('admin:event_status', kwargs={'slug': self.event.slug})
-
-    def form_valid(self, form):
-        virtual_rooms_support = False
-        created_count = 0
-
-        rooms_raw_dict: csv.DictReader = form.cleaned_data["rooms"]
-
-        if apps.is_installed("AKOnline") and "url" in rooms_raw_dict.fieldnames:
-            virtual_rooms_support = True
-            from AKOnline.models import VirtualRoom
-
-        for raw_room in rooms_raw_dict:
-            name = raw_room["name"]
-            location = raw_room["location"] if "location" in rooms_raw_dict.fieldnames else ""
-            capacity = raw_room["capacity"] if "capacity" in rooms_raw_dict.fieldnames else -1
-
-            try:
-                r = Room.objects.create(name=name,
-                                    location=location,
-                                    capacity=capacity,
-                                    event=self.event)
-                if virtual_rooms_support and raw_room["url"] != "":
-                    VirtualRoom.objects.create(room=r,
-                                               url=raw_room["url"])
-                created_count += 1
-            except django.db.Error as e:
-                messages.add_message(self.request, messages.WARNING,
-                                     _("Could not import room {name}: {e}").format(name=name, e=str(e)))
-
-        if created_count > 0:
-            messages.add_message(self.request, messages.SUCCESS,
-                                 _("Imported {count} room(s)").format(count=created_count))
-        else:
-            messages.add_message(self.request, messages.WARNING, _("No rooms imported"))
-        return super().form_valid(form)