AKSolverInterface/serializers.py

+from django.apps import apps
+from rest_framework import serializers
+
+from AKModel.models import AK, AKSlot, Event, Room
+from AKModel.serializers import IntListField, StringListField
+
+class ExportRoomInfoSerializer(serializers.ModelSerializer):
+    """Serializer of Room objects for the 'info' field.
+
+    Used in `ExportRoomSerializer` to serialize Room objects
+    for the export to a solver. Part of the implementation of the
+    format of the KoMa solver:
+    https://github.com/Die-KoMa/ak-plan-optimierung/wiki/Input-&-output-format#input--output-format
+    """
+
+    class Meta:
+        model = Room
+        fields = ["name"]
+        read_only_fields = ["name"]
+
+
+class ExportRoomSerializer(serializers.ModelSerializer):
+    """Export serializer for Room objects.
+
+    Used to serialize Room objects for the export to a solver.
+    Part of the implementation of the format of the KoMa solver:
+    https://github.com/Die-KoMa/ak-plan-optimierung/wiki/Input-&-output-format#input--output-format
+    """
+
+    time_constraints = StringListField(source="get_time_constraints", read_only=True)
+    fulfilled_room_constraints = StringListField(
+        source="get_fulfilled_room_constraints", read_only=True
+    )
+    info = ExportRoomInfoSerializer(source="*")
+
+    class Meta:
+        model = Room
+        fields = [
+            "id",
+            "capacity",
+            "time_constraints",
+            "fulfilled_room_constraints",
+            "info",
+        ]
+        read_only_fields = [
+            "id",
+            "capacity",
+            "time_constraints",
+            "fulfilled_room_constraints",
+            "info",
+        ]
+
+
+class ExportAKSlotInfoSerializer(serializers.ModelSerializer):
+    """Serializer of AKSlot objects for the 'info' field.
+
+    Used in `ExportAKSlotSerializer` to serialize AKSlot objects
+    for the export to a solver. Part of the implementation of the
+    format of the KoMa solver:
+    https://github.com/Die-KoMa/ak-plan-optimierung/wiki/Input-&-output-format#input--output-format
+    """
+
+    name = serializers.CharField(source="ak.name")
+    head = serializers.SerializerMethodField()
+    reso = serializers.BooleanField(source="ak.reso")
+    description = serializers.CharField(source="ak.description")
+    duration_in_hours = serializers.FloatField(source="duration")
+    django_ak_id = serializers.IntegerField(source="ak.pk")
+    types = StringListField(source="type_names")
+
+    def get_head(self, slot: AKSlot) -> str:
+        """Get string representation for 'head' field."""
+        return ", ".join([str(owner) for owner in slot.ak.owners.all()])
+
+    class Meta:
+        model = AKSlot
+        fields = [
+            "name",
+            "head",
+            "description",
+            "reso",
+            "duration_in_hours",
+            "django_ak_id",
+            "types",
+        ]
+        read_only_fields = [
+            "name",
+            "head",
+            "description",
+            "reso",
+            "duration_in_hours",
+            "django_ak_id",
+            "types",
+        ]
+
+
+class ExportAKSlotPropertiesSerializer(serializers.ModelSerializer):
+    """Serializer of AKSlot objects for the 'properties' field.
+
+    Used in `ExportAKSlotSerializer` to serialize AKSlot objects
+    for the export to a solver. Part of the implementation of the
+    format of the KoMa solver:
+    https://github.com/Die-KoMa/ak-plan-optimierung/wiki/Input-&-output-format#input--output-format
+    """
+
+    conflicts = IntListField(source="conflict_pks")
+    dependencies = IntListField(source="depencency_pks")
+
+    class Meta:
+        model = AKSlot
+        fields = ["conflicts", "dependencies"]
+        read_only_fields = ["conflicts", "dependencies"]
+
+
+class ExportAKSlotSerializer(serializers.ModelSerializer):
+    """Export serializer for AKSlot objects.
+
+    Used to serialize AKSlot objects for the export to a solver.
+    Part of the implementation of the format of the KoMa solver:
+    https://github.com/Die-KoMa/ak-plan-optimierung/wiki/Input-&-output-format#input--output-format
+    """
+
+    duration = serializers.IntegerField(source="export_duration")
+    room_constraints = StringListField(source="get_room_constraints")
+    time_constraints = StringListField(source="get_time_constraints")
+    info = ExportAKSlotInfoSerializer(source="*")
+    properties = ExportAKSlotPropertiesSerializer(source="*")
+
+    class Meta:
+        model = AKSlot
+        fields = [
+            "id",
+            "duration",
+            "properties",
+            "room_constraints",
+            "time_constraints",
+            "info",
+        ]
+        read_only_fields = [
+            "id",
+            "duration",
+            "properties",
+            "room_constraints",
+            "time_constraints",
+            "info",
+        ]
+
+
+class ExportParticipantAndDummiesSerializer(serializers.BaseSerializer):
+    """Export serializer for EventParticipant objects that includes 'dummy' participants.
+
+    This serializer is a work-around to make the solver compatible with the AKOwner model.
+
+    Internally, `ExportParticipantSerializer` is used to serialize all EventParticipants of
+    the event to serialize. To avoid scheduling conflicts, a 'dummy' participant is then added
+    to the list for each AKOwner of the event. These dummy participants only have 'required'
+    preference for all AKs of the owner, so the target of the optimization is not impacted.
+
+    Part of the implementation of the format of the KoMa solver:
+    https://github.com/Die-KoMa/ak-plan-optimierung/wiki/Input-&-output-format#input--output-format
+    """
+
+    def create(self, validated_data):
+        raise ValueError("`ExportParticipantAndDummiesSerializer` is read-only.")
+
+    def to_internal_value(self, data):
+        raise ValueError("`ExportParticipantAndDummiesSerializer` is read-only.")
+
+    def update(self, instance, validated_data):
+        raise ValueError("`ExportParticipantAndDummiesSerializer` is read-only.")
+
+    def to_representation(self, instance: Event):
+        event = instance
+
+        # default case
+        real_participants = []
+        next_participant_pk = 1
+
+        # set variable values if AKPreference app is installed
+        if apps.is_installed("AKPreference"):
+            # local import to decouple
+            # pylint: disable=import-outside-toplevel
+            from AKPreference.models import EventParticipant
+            from AKPreference.serializers import ExportParticipantSerializer
+
+            real_participants = ExportParticipantSerializer(event.participants, many=True).data
+            if EventParticipant.objects.exists():
+                next_participant_pk = EventParticipant.objects.latest("pk").pk + 1
+
+        dummies = []
+        # add one dummy participant per owner
+        # this ensures that the hard constraints from each owner are considered
+        for new_pk, owner in enumerate(event.owners, next_participant_pk):
+            owned_slots = event.slots.filter(ak__owners=owner).order_by().all()
+            if not owned_slots:
+                continue
+            new_participant_data = {
+                "id": new_pk,
+                "info": {"name": f"{owner} [AKOwner]"},
+                "room_constraints": [],
+                "time_constraints": [],
+                "preferences": [
+                    {"ak_id": slot.pk, "required": True, "preference_score": -1}
+                    for slot in owned_slots
+                ]
+            }
+            dummies.append(new_participant_data)
+        return real_participants + dummies
+
+
+class ExportEventInfoSerializer(serializers.ModelSerializer):
+    """Serializer of an Event object for the 'info' field.
+
+    Used in `ExportEventSerializer` to serialize an Event object
+    for the export to a solver. Part of the implementation of the
+    format of the KoMa solver:
+    https://github.com/Die-KoMa/ak-plan-optimierung/wiki/Input-&-output-format#input--output-format
+    """
+
+    title = serializers.CharField(source="name")
+    contact_email = serializers.EmailField(required=False)
+    place = serializers.CharField(required=False)
+
+    class Meta:
+        model = Event
+        fields = ["title", "slug", "contact_email", "place"]
+
+
+class ExportTimeslotBlockSerializer(serializers.BaseSerializer):
+    """Read-only serializer for timeslots.
+
+    Used to serialize timeslots for the export to a solver.
+    Part of the implementation of the format of the KoMa solver:
+    https://github.com/Die-KoMa/ak-plan-optimierung/wiki/Input-&-output-format#input--output-format
+    """
+
+    def create(self, validated_data):
+        raise ValueError("`ExportTimeslotBlockSerializer` is read-only.")
+
+    def to_internal_value(self, data):
+        raise ValueError("`ExportTimeslotBlockSerializer` is read-only.")
+
+    def update(self, instance, validated_data):
+        raise ValueError("`ExportTimeslotBlockSerializer` is read-only.")
+
+    def to_representation(self, instance: Event):
+        """Construct serialized representation of the timeslots of an event."""
+        # pylint: disable=import-outside-toplevel
+        from AKModel.availability.models import Availability
+
+        event = instance
+        blocks = list(event.discretize_timeslots())
+
+        def _check_event_not_covered(availabilities: list[Availability]) -> bool:
+            """Test if event is not covered by availabilities."""
+            return not Availability.is_event_covered(event, availabilities)
+
+        def _check_akslot_fixed_in_timeslot(
+            ak_slot: AKSlot, timeslot: Availability
+        ) -> bool:
+            """Test if an AKSlot is fixed to overlap a timeslot slot."""
+            if not ak_slot.fixed or ak_slot.start is None:
+                return False
+
+            fixed_avail = Availability(
+                event=event, start=ak_slot.start, end=ak_slot.end
+            )
+            return fixed_avail.overlaps(timeslot, strict=True)
+
+        def _check_add_constraint(
+            slot: Availability, availabilities: list[Availability]
+        ) -> bool:
+            """Test if object is not available for whole event and may happen during slot."""
+            return _check_event_not_covered(availabilities) and slot.is_covered(
+                availabilities
+            )
+
+        def _generate_time_constraints(
+            avail_label: str,
+            avail_dict: dict,
+            timeslot_avail: Availability,
+            prefix: str = "availability",
+        ) -> list[str]:
+            return [
+                f"{prefix}-{avail_label}-{pk}"
+                for pk, availabilities in avail_dict.items()
+                if _check_add_constraint(timeslot_avail, availabilities)
+            ]
+
+        timeslots = {
+            "info": {"duration": float(event.export_slot)},
+            "blocks": [],
+        }
+
+        ak_availabilities = {
+            ak.pk: Availability.union(ak.availabilities.all())
+            for ak in AK.objects.filter(event=event).all()
+        }
+        room_availabilities = {
+            room.pk: Availability.union(room.availabilities.all()) for room in event.rooms
+        }
+        person_availabilities = {
+            person.pk: Availability.union(person.availabilities.all())
+            for person in event.owners
+        }
+        participant_availabilities = {
+            participant.pk: Availability.union(participant.availabilities.all())
+            for participant in event.participants
+        }
+
+        block_names = []
+        for block_idx, block in enumerate(blocks):
+            current_block = []
+
+            if not block:
+                continue
+
+            block_start = block[0].avail.start.astimezone(event.timezone)
+            block_end = block[-1].avail.end.astimezone(event.timezone)
+
+            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])
+
+            block_timeconstraints = [
+                f"notblock{idx}" for idx in range(len(blocks)) if idx != block_idx
+            ]
+
+            for timeslot in block:
+                time_constraints = []
+                # if reso_deadline is set and timeslot ends before it,
+                #   add fulfilled time constraint 'resolution'
+                if (
+                    event.reso_deadline is None
+                    or timeslot.avail.end < event.reso_deadline
+                ):
+                    time_constraints.append("resolution")
+
+                # add fulfilled time constraints for all AKs that cannot happen during full event
+                time_constraints.extend(
+                    _generate_time_constraints("ak", ak_availabilities, timeslot.avail)
+                )
+
+                # add fulfilled time constraints for all persons that are not available for full event
+                time_constraints.extend(
+                    _generate_time_constraints(
+                        "person", person_availabilities, timeslot.avail
+                    )
+                )
+
+                # add fulfilled time constraints for all rooms that are not available for full event
+                time_constraints.extend(
+                    _generate_time_constraints(
+                        "room", room_availabilities, timeslot.avail
+                    )
+                )
+
+                # add fulfilled time constraints for all participants that are not available for full event
+                time_constraints.extend(
+                    _generate_time_constraints(
+                        "participant", participant_availabilities, timeslot.avail
+                    )
+                )
+
+                # add fulfilled time constraints for all AKSlots fixed to happen during timeslot
+                time_constraints.extend(
+                    [
+                        f"fixed-akslot-{slot.id}"
+                        for slot in AKSlot.objects.filter(
+                            event=event, fixed=True
+                        ).exclude(start__isnull=True)
+                        if _check_akslot_fixed_in_timeslot(slot, timeslot.avail)
+                    ]
+                )
+
+                time_constraints.extend(timeslot.constraints)
+                time_constraints.extend(block_timeconstraints)
+                time_constraints.sort()
+
+                current_block.append(
+                    {
+                        "id": timeslot.idx,
+                        "info": {
+                            "start": timeslot.avail.start.astimezone(
+                                event.timezone
+                            ).strftime("%Y-%m-%d %H:%M"),
+                            "end": timeslot.avail.end.astimezone(
+                                event.timezone
+                            ).strftime("%Y-%m-%d %H:%M"),
+                        },
+                        "fulfilled_time_constraints": time_constraints,
+                    }
+                )
+
+            timeslots["blocks"].append(current_block)
+
+        timeslots["info"]["blocknames"] = block_names
+
+        return timeslots
+
+
+class ExportEventSerializer(serializers.ModelSerializer):
+    """Export serializer for an Event object.
+
+    Used to serialize an Event for the export to a solver.
+    Part of the implementation of the format of the KoMa solver:
+    https://github.com/Die-KoMa/ak-plan-optimierung/wiki/Input-&-output-format#input--output-format
+    """
+
+    info = ExportEventInfoSerializer(source="*")
+    rooms = ExportRoomSerializer(many=True)
+    aks = ExportAKSlotSerializer(source="slots", many=True)
+    participants = ExportParticipantAndDummiesSerializer(source="*")
+    timeslots = ExportTimeslotBlockSerializer(source="*")
+
+    class Meta:
+        model = Event
+        fields = ["participants", "rooms", "timeslots", "info", "aks"]
+        read_only_fields = ["participants", "rooms", "timeslots", "info", "aks"]

AKSolverInterface/templates/admin/AKSolverInterface/ak_json_export.html

+{% extends "admin/base_site.html" %}
+
+{% load tz %}
+
+{% block content %}
+
+<div class="mb-3">
+  <label for="export_single_line" class="form-label">Exported JSON:</label>
+  <input readonly type="text" name="export_single_line" class="form-control form-control-sm" value="{{ json_data_oneline }}"  style="font-family:var(--font-family-monospace);">
+</div>
+
+<div class="mb-3">
+  <label class="form-label">Exported JSON (indented for better readability):</label>
+  <pre class="prettyprint border rounded p-2">{{ json_data }}</pre>
+</div>
+
+<script>
+  $(document).ready(function() {
+    // JSON highlighting.
+    prettyPrint();
+    }
+  )
+</script>
+{% endblock %}

AKSolverInterface/templates/admin/AKSolverInterface/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 %}

AKSolverInterface/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 AKPreference.models import AKPreference, EventParticipant
+from AKSolverInterface.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.participants: Iterable[EventParticipant] = []
+        self.owners: Iterable[AKOwner] = []
+        self.slots_in_an_hour: float = 1.0
+        self.max_participant_pk = 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.participants = EventParticipant.objects.filter(
+            event__slug=event.slug
+        ).all()
+        self.owners = AKOwner.objects.filter(event__slug=event.slug).all()
+
+        self.max_participant_pk = (
+            self.participants.latest("pk").pk if self.participants else 0
+        )
+
+        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)
+
+                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 self.owners
+                            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 participant constraints
+                        fulfilled_time_constraints |= {
+                            f"availability-participant-{participant.id}"
+                            for participant in self.participants
+                            if self._is_restricted_and_contained_slot(
+                                timeslot_avail,
+                                Availability.union(participant.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"]
+                )
+
+    def _owner_has_ak(self, owner: AKOwner) -> bool:
+        owned_aks = self.ak_slots.filter(ak__owners=owner).all()
+        return bool(owned_aks)
+
+    def test_all_participants_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)
+
+                participant_ids = set(self.participants.values_list("pk", flat=True))
+                for idx, owner in enumerate(self.owners, self.max_participant_pk + 1):
+                    if self._owner_has_ak(owner):
+                        participant_ids.add(idx)
+
+                self.assertEqual(
+                    participant_ids,
+                    self.export_objects["participants"].keys(),
+                    "Exported Participants does not match the Participants of the event",
+                )
+
+    def test_participant_info(self):
+        """Test if contents of participants info dict is correct."""
+        for event in Event.objects.all():
+            with self.subTest(event=event):
+                self.set_up_event(event=event)
+
+                for participant in self.participants:
+                    export_participant = self.export_objects["participants"][
+                        participant.pk
+                    ]
+                    self.assertEqual(
+                        str(participant), export_participant["info"]["name"]
+                    )
+
+                for idx, owner in enumerate(self.owners, self.max_participant_pk + 1):
+                    if not self._owner_has_ak(owner):
+                        continue
+                    export_participant = self.export_objects["participants"][idx]
+                    self.assertEqual(
+                        str(owner) + " [AKOwner]", export_participant["info"]["name"]
+                    )
+
+    def test_participant_timeconstraints(self):
+        """Test if participant time constraints are exported as expected."""
+        for event in Event.objects.all():
+            with self.subTest(event=event):
+                self.set_up_event(event=event)
+                for participant in self.participants:
+                    export_participant = self.export_objects["participants"][
+                        participant.pk
+                    ]
+
+                    time_constraints = set()
+                    participant_avails = participant.availabilities.all()
+                    if participant_avails and not Availability.is_event_covered(
+                        self.event, participant_avails
+                    ):
+                        # participant has restricted availability
+                        if AKPreference.objects.filter(
+                            event=self.event,
+                            participant=participant,
+                            preference=AKPreference.PreferenceLevel.REQUIRED,
+                        ):
+                            # partipant is actually required for AKs
+                            time_constraints.add(
+                                f"availability-participant-{participant.pk}"
+                            )
+
+                    self.assertEqual(
+                        set(export_participant["time_constraints"]), time_constraints
+                    )
+
+                # dummy participants have no time constraints
+                for idx, owner in enumerate(self.owners, self.max_participant_pk + 1):
+                    if not self._owner_has_ak(owner):
+                        continue
+                    export_participant = self.export_objects["participants"][idx]
+                    self.assertEqual(export_participant["time_constraints"], [])
+
+    def test_participant_roomconstraints(self):
+        """Test if participant room constraints are exported as expected."""
+        for event in Event.objects.all():
+            with self.subTest(event=event):
+                self.set_up_event(event=event)
+                for participant in self.participants:
+                    export_participant = self.export_objects["participants"][
+                        participant.pk
+                    ]
+                    room_constraints = [
+                        constr.name for constr in participant.requirements.all()
+                    ]
+                    self.assertCountEqual(
+                        export_participant["room_constraints"], room_constraints
+                    )
+
+                for idx, owner in enumerate(self.owners, self.max_participant_pk + 1):
+                    if not self._owner_has_ak(owner):
+                        continue
+                    export_participant = self.export_objects["participants"][idx]
+                    self.assertEqual(export_participant["room_constraints"], [])
+
+    def test_preferences(self):
+        """Test if preferences are exported as expected."""
+
+        def _preference_json(pref: AKPreference):
+            return {
+                "ak_id": pref.slot.pk,
+                "required": pref.preference == AKPreference.PreferenceLevel.REQUIRED,
+                "preference_score": (
+                    pref.preference
+                    if pref.preference != AKPreference.PreferenceLevel.REQUIRED
+                    else -1
+                ),
+            }
+
+        for event in Event.objects.all():
+            with self.subTest(event=event):
+                self.set_up_event(event=event)
+                for participant in self.participants:
+                    export_participant = self.export_objects["participants"][
+                        participant.pk
+                    ]
+                    preferences = [
+                        _preference_json(pref)
+                        for pref in AKPreference.objects.filter(
+                            participant=participant, preference__gt=0
+                        ).select_related("slot")
+                    ]
+                    self.assertCountEqual(
+                        export_participant["preferences"], preferences
+                    )
+
+                for idx, owner in enumerate(self.owners, self.max_participant_pk + 1):
+                    owned_slots = self.ak_slots.filter(ak__owners=owner).all()
+                    if not owned_slots:
+                        continue
+                    preferences = [
+                        {
+                            "ak_id": slot.pk,
+                            "required": True,
+                            "preference_score": -1,
+                        }
+                        for slot in owned_slots
+                    ]
+                    export_participant = self.export_objects["participants"][idx]
+                    self.assertCountEqual(
+                        export_participant["preferences"], preferences
+                    )

AKSolverInterface/tests/test_views.py

+from django.test import TestCase
+
+from AKModel.tests.test_views import BasicViewTests
+
+
+class ModelViewTests(BasicViewTests, TestCase):
+    """
+    Tests for AKSolverInterface
+    """
+
+    fixtures = ["model.json"]
+
+    VIEWS_STAFF_ONLY = [
+        ("admin:ak_json_export", {"event_slug": "kif42"}),
+        ("admin:ak_schedule_json_import", {"event_slug": "kif42"}),
+    ]

AKSolverInterface/urls.py

+from django.urls import path
+
+from .views import AKJSONExportView, AKScheduleJSONImportView
+
+
+def get_admin_urls_solver_interface(admin_site):
+    return [
+        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",
+        ),
+    ]

AKSolverInterface/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)

AKSolverInterface/views.py

+import json
+
+from django.contrib import messages
+from django.shortcuts import redirect
+from django.utils.translation import gettext_lazy as _
+from django.views.generic import DetailView
+
+from AKModel.metaviews.admin import (
+    AdminViewMixin,
+    EventSlugMixin,
+    IntermediateAdminView,
+)
+from AKModel.models import Event
+from AKSolverInterface.forms import JSONScheduleImportForm
+from AKSolverInterface.serializers import ExportEventSerializer
+
+
+class AKJSONExportView(AdminViewMixin, DetailView):
+    """
+    View: Export all AK slots of this event in JSON format ordered by tracks
+    """
+
+    template_name = "admin/AKSolverInterface/ak_json_export.html"
+    model = Event
+    context_object_name = "event"
+    title = _("AK JSON Export")
+    slug_url_kwarg = "event_slug"
+
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        try:
+            serialized_event = ExportEventSerializer(context["event"])
+            context["json_data_oneline"] = json.dumps(serialized_event.data, ensure_ascii=False)
+            context["json_data"] = json.dumps(serialized_event.data, indent=2, ensure_ascii=False)
+            context["is_valid"] = True
+        except ValueError as ex:
+            messages.add_message(
+                self.request,
+                messages.ERROR,
+                _("Exporting AKs for the solver failed! Reason: ") + str(ex),
+            )
+        return context
+
+    def get(self, request, *args, **kwargs):
+        # as this code is adapted from BaseDetailView::get
+        # pylint: disable=attribute-defined-outside-init
+        self.object = self.get_object()
+        context = self.get_context_data(object=self.object)
+
+        # if serialization failed in `get_context_data` we redirect to
+        #   the status page and show a message instead
+        if not context.get("is_valid", False):
+            return redirect("admin:event_status", context["event"].slug)
+        return self.render_to_response(context)
+
+
+class AKScheduleJSONImportView(EventSlugMixin, IntermediateAdminView):
+    """
+    View: Import an AK schedule from a json file that can be pasted into this view.
+    """
+
+    template_name = "admin/AKSolverInterface/import_json.html"
+    form_class = JSONScheduleImportForm
+    title = _("AK Schedule JSON Import")
+
+    def form_valid(self, form):
+        try:
+            number_of_slots_changed = self.event.schedule_from_json(
+                form.cleaned_data["data"]
+            )
+            messages.add_message(
+                self.request,
+                messages.SUCCESS,
+                _("Successfully imported {n} slot(s)").format(
+                    n=number_of_slots_changed
+                ),
+            )
+        except ValueError as ex:
+            messages.add_message(
+                self.request,
+                messages.ERROR,
+                _("Importing an AK schedule failed! Reason: ") + str(ex),
+            )
+
+        return redirect("admin:event_status", self.event.slug)

AKSubmission/admin.py

-# Register your models here.

AKSubmission/api.py

+from datetime import datetime
+
 from rest_framework import status
 from rest_framework.decorators import api_view
 from rest_framework.response import Response
-from django.utils.datetime_safe import datetime
 
 from AKModel.models import AK
 
@@ -17,17 +18,21 @@ def ak_interest_indication_active(event, current_timestamp):
     :return: True if indication is allowed, False if not
     :rtype: Bool
     """
-    return event.active and (event.interest_start is None or (event.interest_start <= current_timestamp and (
-            event.interest_end is None or current_timestamp <= event.interest_end)))
+    return (event.active and event.interest_start is not None and event.interest_end is not None
+            and event.interest_start <= current_timestamp <= event.interest_end)
 
 
 @api_view(['POST'])
 def increment_interest_counter(request, event_slug, pk, **kwargs):
     """
     Increment interest counter for AK
+
+    This view either returns an HTTP 200 if the counter was incremented,
+    an HTTP 403 if indicating interest is currently not allowed,
+    or an HTTP 404 if there is no matching AK for the given primary key and event slug.
     """
     try:
-        ak = AK.objects.get(pk=pk)
+        ak = AK.objects.get(pk=pk, event__slug=event_slug)
         # Check whether interest indication is currently allowed
         current_timestamp = datetime.now().astimezone(ak.event.timezone)
         if ak_interest_indication_active(ak.event, current_timestamp):

AKSubmission/apps.py

@@ -2,4 +2,7 @@ from django.apps import AppConfig
 
 
 class AksubmissionConfig(AppConfig):
+    """
+    App configuration (default, only specifies name of the app)
+    """
     name = 'AKSubmission'

AKSubmission/forms.py

+"""
+Submission-specific forms
+"""
+
 import itertools
 import re
 
@@ -7,10 +11,21 @@ from django.utils.translation import gettext_lazy as _
 
 from AKModel.availability.forms import AvailabilitiesFormMixin
 from AKModel.availability.models import Availability
-from AKModel.models import AK, AKOwner, AKCategory, AKRequirement, AKSlot, AKOrgaMessage, Event
+from AKModel.models import AK, AKOwner, AKCategory, AKRequirement, AKSlot, AKOrgaMessage, AKType
 
 
 class AKForm(AvailabilitiesFormMixin, forms.ModelForm):
+    """
+    Base form to add and edit AKs
+
+    Contains suitable widgets for the different data types, restricts querysets (e.g., of requirements) to entries
+    belonging to the event this AK belongs to.
+    Prepares initial slot creation (by accepting multiple input formats and a list of slots to generate),
+    automatically generate short names and wiki links if necessary
+
+    Will be modified/used by :class:`AKSubmissionForm` (that allows to add slots and excludes links)
+    and :class:`AKWishForm`
+    """
     required_css_class = 'required'
     split_string = re.compile('[,;]')
 
@@ -18,11 +33,11 @@ class AKForm(AvailabilitiesFormMixin, forms.ModelForm):
         model = AK
         fields = ['name',
                   'short_name',
-                  'link',
                   'protocol_link',
                   'owners',
                   'description',
                   'category',
+                  'types',
                   'reso',
                   'present',
                   'requirements',
@@ -34,6 +49,7 @@ class AKForm(AvailabilitiesFormMixin, forms.ModelForm):
 
         widgets = {
             'requirements': forms.CheckboxSelectMultiple,
+            'types': forms.CheckboxSelectMultiple,
             'event': forms.HiddenInput,
         }
 
@@ -47,7 +63,14 @@ class AKForm(AvailabilitiesFormMixin, forms.ModelForm):
         self.fields["prerequisites"].widget.attrs = {'class': 'chosen-select'}
 
         self.fields['category'].queryset = AKCategory.objects.filter(event=self.initial.get('event'))
+        self.fields['types'].queryset = AKType.objects.filter(event=self.initial.get('event'))
+        # Don't ask for types if there are no types configured for this event
+        if self.fields['types'].queryset.count() == 0:
+            self.fields.pop('types')
         self.fields['requirements'].queryset = AKRequirement.objects.filter(event=self.initial.get('event'))
+        # Don't ask for requirements if there are no requirements configured for this event
+        if self.fields['requirements'].queryset.count() == 0:
+            self.fields.pop('requirements')
         self.fields['prerequisites'].queryset = AK.objects.filter(event=self.initial.get('event')).exclude(
             pk=self.instance.pk)
         self.fields['conflicts'].queryset = AK.objects.filter(event=self.initial.get('event')).exclude(
@@ -57,7 +80,14 @@ class AKForm(AvailabilitiesFormMixin, forms.ModelForm):
 
     @staticmethod
     def _clean_duration(duration):
-        # Handle different duration formats (h:mm and decimal comma instead of point)
+        """
+        Clean/convert input format for the duration(s) of the slot(s)
+
+        Handle different duration formats (h:mm and decimal comma instead of point)
+
+        :param duration: raw input, either with ":", "," or "."
+        :return: normalized duration (point-separated hour float)
+        """
         if ":" in duration:
             h, m = duration.split(":")
             duration = int(h) + int(m) / 60
@@ -65,40 +95,47 @@ class AKForm(AvailabilitiesFormMixin, forms.ModelForm):
             duration = float(duration.replace(",", "."))
 
         try:
-            float(duration)
-        except ValueError:
+            duration = float(duration)
+        except ValueError as exc:
             raise ValidationError(
                 _('"%(duration)s" is not a valid duration'),
                 code='invalid',
                 params={'duration': duration},
-            )
+            ) from exc
 
         return duration
 
     def clean(self):
+        """
+        Normalize/clean inputs
+
+        Generate a (not yet used) short name if field was left blank,
+        create a list of normalized slot durations
+
+        :return: cleaned inputs
+        """
         cleaned_data = super().clean()
 
         # Generate short name if not given
         short_name = self.cleaned_data["short_name"]
         if len(short_name) == 0:
             short_name = self.cleaned_data['name']
+            # First try to split AK name at positions with semantic value (e.g., where the full name is separated
+            # by a ':'), if not possible, do a hard cut at the maximum specified length
             short_name = short_name.partition(':')[0]
             short_name = short_name.partition(' - ')[0]
             short_name = short_name.partition(' (')[0]
             short_name = short_name[:AK._meta.get_field('short_name').max_length]
+            # Check whether this short name already exists...
             for i in itertools.count(1):
+                # ...and either use it...
                 if not AK.objects.filter(short_name=short_name, event=self.cleaned_data["event"]).exists():
                     break
+                # ... or postfix a number starting at 1 and growing until an unused short name is found
                 digits = len(str(i))
-                short_name = '{}-{}'.format(short_name[:-(digits + 1)], i)
+                short_name = f'{short_name[:-(digits + 1)]}-{i}'
             cleaned_data["short_name"] = short_name
 
-        # Generate wiki link
-        if self.cleaned_data["event"].base_url:
-            link = self.cleaned_data["event"].base_url + self.cleaned_data["name"].replace(" ", "_")
-            # Truncate links longer than 200 characters (default length of URL fields in django)
-            self.cleaned_data["link"] = link[:200]
-
         # Get durations from raw durations field
         if "durations" in cleaned_data:
             cleaned_data["durations"] = [self._clean_duration(d) for d in self.cleaned_data["durations"].split()]
@@ -106,35 +143,63 @@ class AKForm(AvailabilitiesFormMixin, forms.ModelForm):
 
 
 class AKSubmissionForm(AKForm):
+    """
+    Form for Submitting new AKs
+
+    Is a special variant of :class:`AKForm` that does not allow to manually edit wiki and protocol links and enforces
+    the generation of at least one slot.
+    """
     class Meta(AKForm.Meta):
-        exclude = ['link', 'protocol_link']
+        # Exclude fields again that were previously included in the parent class
+        exclude = ['link', 'protocol_link'] #pylint: disable=modelform-uses-exclude
+        widgets = AKForm.Meta.widgets | {
+            'types': forms.CheckboxSelectMultiple(attrs={'checked' : 'checked'}),
+        }
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        # Add field for durations
+        # Add field for durations (cleaning will be handled by parent class)
         self.fields["durations"] = forms.CharField(
             widget=forms.Textarea,
             label=_("Duration(s)"),
             help_text=_(
-                "Enter at least one planned duration (in hours). If your AK should have multiple slots, use multiple lines"),
-            initial=
-            self.initial.get('event').default_slot
+                "Enter at least one planned duration (in hours). "
+                "If your AK should have multiple slots, use multiple lines"),
+            initial=self.initial.get('event').default_slot
         )
 
     def clean_availabilities(self):
+        """
+        Automatically improve availabilities entered.
+        If the user did not specify availabilities assume the full event duration is possible
+        :return: cleaned availabilities
+        (either user input or one availability for the full length of the event if user input was empty)
+        """
         availabilities = super().clean_availabilities()
-        # If the user did not specify availabilities assume the full event duration is possible
         if len(availabilities) == 0:
             availabilities.append(Availability.with_event_length(event=self.cleaned_data["event"]))
         return availabilities
 
 
 class AKWishForm(AKForm):
+    """
+    Form for submitting or editing wishes
+
+    Is a special variant of :class:`AKForm` that does not allow to specify owner(s) or
+    manually edit wiki and protocol links
+    """
     class Meta(AKForm.Meta):
-        exclude = ['owners', 'link', 'protocol_link']
+        # Exclude fields again that were previously included in the parent class
+        exclude = ['owners', 'link', 'protocol_link'] #pylint: disable=modelform-uses-exclude
+        widgets = AKForm.Meta.widgets | {
+            'types': forms.CheckboxSelectMultiple(attrs={'checked': 'checked'}),
+        }
 
 
 class AKOwnerForm(forms.ModelForm):
+    """
+    Form to create/edit AK owners
+    """
     required_css_class = 'required'
 
     class Meta:
@@ -146,6 +211,9 @@ class AKOwnerForm(forms.ModelForm):
 
 
 class AKDurationForm(forms.ModelForm):
+    """
+    Form to add an additional slot to a given AK
+    """
     class Meta:
         model = AKSlot
         fields = ['duration', 'ak', 'event']
@@ -156,6 +224,9 @@ class AKDurationForm(forms.ModelForm):
 
 
 class AKOrgaMessageForm(forms.ModelForm):
+    """
+    Form to create a confidential message to the organizers  belonging to a given AK
+    """
     class Meta:
         model = AKOrgaMessage
         fields = ['ak', 'text', 'event']
@@ -164,14 +235,3 @@ class AKOrgaMessageForm(forms.ModelForm):
             'event': forms.HiddenInput,
             'text': forms.Textarea,
         }
-
-
-class AKAddSlotForm(forms.Form):
-    start = forms.CharField(label=_("Start"), disabled=True)
-    end = forms.CharField(label=_("End"), disabled=True)
-    duration = forms.CharField(label=_("Duration"), disabled=True)
-    room = forms.IntegerField(label=_("Room"), disabled=True)
-
-    def __init__(self, event):
-        super().__init__()
-        self.fields['ak'] = forms.ModelChoiceField(event.ak_set.all(), label=_("AK"))

AKSubmission/locale/de_DE/LC_MESSAGES/django.po

@@ -8,7 +8,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: PACKAGE VERSION\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2023-03-26 19:51+0200\n"
+"POT-Creation-Date: 2025-06-16 12:25+0200\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <LL@li.org>\n"
@@ -17,16 +17,16 @@ msgstr ""
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
 
-#: AKSubmission/forms.py:71
+#: AKSubmission/forms.py:101
 #, python-format
 msgid "\"%(duration)s\" is not a valid duration"
 msgstr "\"%(duration)s\" ist keine gültige Dauer"
 
-#: AKSubmission/forms.py:117
+#: AKSubmission/forms.py:164
 msgid "Duration(s)"
 msgstr "Dauer(n)"
 
-#: AKSubmission/forms.py:119
+#: AKSubmission/forms.py:166
 msgid ""
 "Enter at least one planned duration (in hours). If your AK should have "
 "multiple slots, use multiple lines"
@@ -34,33 +34,6 @@ msgstr ""
 "Mindestens eine geplante Dauer (in Stunden) angeben. Wenn der AK mehrere "
 "Slots haben soll, mehrere Zeilen verwenden"
 
-#: AKSubmission/forms.py:170
-#: AKSubmission/templates/AKSubmission/ak_detail.html:309
-msgid "Start"
-msgstr "Start"
-
-#: AKSubmission/forms.py:171
-#: AKSubmission/templates/AKSubmission/ak_detail.html:310
-msgid "End"
-msgstr "Ende"
-
-#: AKSubmission/forms.py:172
-#: AKSubmission/templates/AKSubmission/ak_detail.html:239
-#: AKSubmission/templates/AKSubmission/akslot_delete.html:35
-msgid "Duration"
-msgstr "Dauer"
-
-#: AKSubmission/forms.py:173
-#: AKSubmission/templates/AKSubmission/ak_detail.html:241
-msgid "Room"
-msgstr "Raum"
-
-#: AKSubmission/forms.py:177
-#: AKSubmission/templates/AKSubmission/ak_history.html:11
-#: AKSubmission/templates/AKSubmission/akslot_delete.html:31
-msgid "AK"
-msgstr "AK"
-
 #: AKSubmission/templates/AKSubmission/ak_detail.html:22
 #: AKSubmission/templates/AKSubmission/ak_edit.html:13
 #: AKSubmission/templates/AKSubmission/ak_history.html:16
@@ -74,163 +47,181 @@ msgstr "AK"
 #: AKSubmission/templates/AKSubmission/submission_overview.html:7
 #: AKSubmission/templates/AKSubmission/submission_overview.html:11
 #: AKSubmission/templates/AKSubmission/submission_overview.html:36
-#: AKSubmission/templates/AKSubmission/submit_new.html:31
+#: AKSubmission/templates/AKSubmission/submit_new.html:77
 #: AKSubmission/templates/AKSubmission/submit_new_wish.html:13
 msgid "AK Submission"
 msgstr "AK-Eintragung"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:77
+#: AKSubmission/templates/AKSubmission/ak_detail.html:126
 #: AKSubmission/templates/AKSubmission/ak_interest_script.html:50
 msgid "Interest indication currently not allowed. Sorry."
 msgstr "Interessenangabe aktuell nicht erlaubt. Sorry."
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:79
+#: AKSubmission/templates/AKSubmission/ak_detail.html:128
 #: AKSubmission/templates/AKSubmission/ak_interest_script.html:52
 msgid "Could not save your interest. Sorry."
 msgstr "Interesse konnte nicht gespeichert werden. Sorry."
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:100
+#: AKSubmission/templates/AKSubmission/ak_detail.html:149
 msgid "Interest"
 msgstr "Interesse"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:102
-#: AKSubmission/templates/AKSubmission/ak_table.html:55
+#: AKSubmission/templates/AKSubmission/ak_detail.html:151
+#: AKSubmission/templates/AKSubmission/ak_table.html:65
 msgid "Show Interest"
 msgstr "Interesse bekunden"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:108
-#: AKSubmission/templates/AKSubmission/ak_table.html:46
+#: AKSubmission/templates/AKSubmission/ak_detail.html:157
+#: AKSubmission/templates/AKSubmission/ak_table.html:56
 msgid "Open external link"
 msgstr "Externen Link öffnen"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:113
+#: AKSubmission/templates/AKSubmission/ak_detail.html:162
 msgid "Open protocol link"
 msgstr "Protokolllink öffnen"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:118
+#: AKSubmission/templates/AKSubmission/ak_detail.html:167
 #: AKSubmission/templates/AKSubmission/ak_history.html:19
 #: AKSubmission/templates/AKSubmission/ak_history.html:31
 msgid "History"
 msgstr "Versionsgeschichte"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:121
+#: AKSubmission/templates/AKSubmission/ak_detail.html:170
 #: AKSubmission/templates/AKSubmission/akmessage_add.html:8
 #: AKSubmission/templates/AKSubmission/akmessage_add.html:16
 #: AKSubmission/templates/AKSubmission/akmessage_add.html:22
 msgid "Add confidential message to organizers"
 msgstr "Sende eine private Nachricht an das Organisationsteam"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:124
-#: AKSubmission/templates/AKSubmission/ak_detail.html:269
+#: AKSubmission/templates/AKSubmission/ak_detail.html:173
+#: AKSubmission/templates/AKSubmission/ak_detail.html:326
 #: AKSubmission/templates/AKSubmission/ak_edit.html:16
-#: AKSubmission/templates/AKSubmission/ak_table.html:51
+#: AKSubmission/templates/AKSubmission/ak_table.html:61
 msgid "Edit"
 msgstr "Bearbeiten"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:129
+#: AKSubmission/templates/AKSubmission/ak_detail.html:178
 #: AKSubmission/templates/AKSubmission/ak_history.html:31
-#: AKSubmission/templates/AKSubmission/ak_table.html:34
+#: AKSubmission/templates/AKSubmission/ak_table.html:37
 msgid "AK Wish"
 msgstr "AK-Wunsch"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:136
+#: AKSubmission/templates/AKSubmission/ak_detail.html:186
 #, python-format
 msgid ""
-"\n"
-"                        This AK currently takes place for another "
-"%(featured_slot_remaining)s minute(s) in %(room)s.\n"
-"                        &nbsp;\n"
-"                    "
+"This AK currently takes place for another <span v-"
+"html=\"timeUntilEnd\">%(featured_slot_remaining)s</span> minute(s) in "
+"%(room)s.&nbsp;"
 msgstr ""
-"\n"
-"                        Dieser AK findet noch %(featured_slot_remaining)s "
-"Minute(n) in %(room)s statt.&nbsp;\n"
+"Dieser AK findet noch <span v-"
+"html=\"timeUntilEnd\">%(featured_slot_remaining)s</span> Minute(n) in "
+"%(room)s statt.&nbsp;\n"
 "                    "
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:142
+#: AKSubmission/templates/AKSubmission/ak_detail.html:189
 #, python-format
 msgid ""
-"\n"
-"                        This AK starts in %(featured_slot_remaining)s "
-"minute(s) in %(room)s.&nbsp;\n"
-"                    "
+"This AK starts in <span v-"
+"html=\"timeUntilStart\">%(featured_slot_remaining)s</span> minute(s) in "
+"%(room)s.&nbsp;"
 msgstr ""
-"\n"
-"                        This AK beginnt in %(featured_slot_remaining)s "
-"Minute(n) in %(room)s.&nbsp;\n"
+"Dieser AK beginnt in <span v-"
+"html=\"timeUntilStart\">%(featured_slot_remaining)s</span> Minute(n) in "
+"%(room)s.&nbsp;\n"
 "                    "
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:149
-#: AKSubmission/templates/AKSubmission/ak_detail.html:277
+#: AKSubmission/templates/AKSubmission/ak_detail.html:194
+#: AKSubmission/templates/AKSubmission/ak_detail.html:334
 msgid "Go to virtual room"
 msgstr "Zum virtuellen Raum"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:158
+#: AKSubmission/templates/AKSubmission/ak_detail.html:205
 #: AKSubmission/templates/AKSubmission/ak_table.html:10
 msgid "Who?"
 msgstr "Wer?"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:164
+#: AKSubmission/templates/AKSubmission/ak_detail.html:211
 #: AKSubmission/templates/AKSubmission/ak_history.html:36
 #: AKSubmission/templates/AKSubmission/ak_table.html:11
 msgid "Category"
 msgstr "Kategorie"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:171
+#: AKSubmission/templates/AKSubmission/ak_detail.html:218
+#: AKSubmission/templates/AKSubmission/ak_list.html:24
+#: AKSubmission/templates/AKSubmission/ak_table.html:13
+msgid "Types"
+msgstr "Typen"
+
+#: AKSubmission/templates/AKSubmission/ak_detail.html:228
 #: AKSubmission/templates/AKSubmission/ak_history.html:37
 msgid "Track"
 msgstr "Track"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:177
-#, fuzzy
-#| msgid "Present results of this AK"
+#: AKSubmission/templates/AKSubmission/ak_detail.html:234
 msgid "Present this AK"
-msgstr "Die Ergebnisse dieses AKs vorstellen"
+msgstr "Diesen AK vorstellen"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:182
+#: AKSubmission/templates/AKSubmission/ak_detail.html:239
 msgid "(Category Default)"
 msgstr "(Kategorievoreinstellung)"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:188
+#: AKSubmission/templates/AKSubmission/ak_detail.html:245
 msgid "Reso intention?"
 msgstr "Resoabsicht?"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:195
+#: AKSubmission/templates/AKSubmission/ak_detail.html:252
 msgid "Requirements"
 msgstr "Anforderungen"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:208
+#: AKSubmission/templates/AKSubmission/ak_detail.html:265
 msgid "Conflicting AKs"
 msgstr "AK-Konflikte"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:216
+#: AKSubmission/templates/AKSubmission/ak_detail.html:273
 msgid "Prerequisite AKs"
 msgstr "Vorausgesetzte AKs"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:224
+#: AKSubmission/templates/AKSubmission/ak_detail.html:281
 msgid "Notes"
 msgstr "Notizen"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:237
+#: AKSubmission/templates/AKSubmission/ak_detail.html:294
 msgid "When?"
 msgstr "Wann?"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:272
+#: AKSubmission/templates/AKSubmission/ak_detail.html:296
+#: AKSubmission/templates/AKSubmission/akslot_delete.html:35
+msgid "Duration"
+msgstr "Dauer"
+
+#: AKSubmission/templates/AKSubmission/ak_detail.html:298
+msgid "Room"
+msgstr "Raum"
+
+#: AKSubmission/templates/AKSubmission/ak_detail.html:329
 msgid "Delete"
 msgstr "Löschen"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:283
+#: AKSubmission/templates/AKSubmission/ak_detail.html:340
 msgid "Schedule"
 msgstr "Schedule"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:295
+#: AKSubmission/templates/AKSubmission/ak_detail.html:352
 msgid "Add another slot"
 msgstr "Einen neuen AK-Slot hinzufügen"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:305
+#: AKSubmission/templates/AKSubmission/ak_detail.html:362
 msgid "Possible Times"
 msgstr "Mögliche Zeiten"
 
+#: AKSubmission/templates/AKSubmission/ak_detail.html:366
+msgid "Start"
+msgstr "Start"
+
+#: AKSubmission/templates/AKSubmission/ak_detail.html:367
+msgid "End"
+msgstr "Ende"
+
 #: AKSubmission/templates/AKSubmission/ak_edit.html:8
 #: AKSubmission/templates/AKSubmission/ak_history.html:11
 #: AKSubmission/templates/AKSubmission/ak_overview.html:8
@@ -260,6 +251,11 @@ msgstr ""
 "Person hinzufügen, die noch nicht in der Liste ist. Ungespeicherte "
 "Änderungen in diesem Formular gehen verloren."
 
+#: AKSubmission/templates/AKSubmission/ak_history.html:11
+#: AKSubmission/templates/AKSubmission/akslot_delete.html:31
+msgid "AK"
+msgstr "AK"
+
 #: AKSubmission/templates/AKSubmission/ak_history.html:27
 msgid "Back"
 msgstr "Zurück"
@@ -274,16 +270,16 @@ msgid "Time"
 msgstr "Zeit"
 
 #: AKSubmission/templates/AKSubmission/ak_history.html:48
-#: AKSubmission/templates/AKSubmission/ak_table.html:25
+#: AKSubmission/templates/AKSubmission/ak_table.html:28
 msgid "Present results of this AK"
 msgstr "Die Ergebnisse dieses AKs vorstellen"
 
 #: AKSubmission/templates/AKSubmission/ak_history.html:52
-#: AKSubmission/templates/AKSubmission/ak_table.html:29
+#: AKSubmission/templates/AKSubmission/ak_table.html:32
 msgid "Intends to submit a resolution"
 msgstr "Beabsichtigt eine Resolution einzureichen"
 
-#: AKSubmission/templates/AKSubmission/ak_list.html:6 AKSubmission/views.py:42
+#: AKSubmission/templates/AKSubmission/ak_list.html:6 AKSubmission/views.py:82
 msgid "All AKs"
 msgstr "Alle AKs"
 
@@ -299,11 +295,11 @@ msgstr "AK-Liste"
 msgid "Add AK"
 msgstr "AK hinzufügen"
 
-#: AKSubmission/templates/AKSubmission/ak_table.html:42
+#: AKSubmission/templates/AKSubmission/ak_table.html:52
 msgid "Details"
 msgstr "Details"
 
-#: AKSubmission/templates/AKSubmission/ak_table.html:66
+#: AKSubmission/templates/AKSubmission/ak_table.html:76
 msgid "There are no AKs in this category yet"
 msgstr "Es gibt noch keine AKs in dieser Kategorie"
 
@@ -314,7 +310,7 @@ msgstr "Senden"
 #: AKSubmission/templates/AKSubmission/akmessage_add.html:31
 #: AKSubmission/templates/AKSubmission/akowner_create_update.html:26
 #: AKSubmission/templates/AKSubmission/akslot_add_update.html:29
-#: AKSubmission/templates/AKSubmission/submit_new.html:52
+#: AKSubmission/templates/AKSubmission/submit_new.html:99
 msgid "Reset Form"
 msgstr "Formular leeren"
 
@@ -322,7 +318,7 @@ msgstr "Formular leeren"
 #: AKSubmission/templates/AKSubmission/akowner_create_update.html:30
 #: AKSubmission/templates/AKSubmission/akslot_add_update.html:33
 #: AKSubmission/templates/AKSubmission/akslot_delete.html:45
-#: AKSubmission/templates/AKSubmission/submit_new.html:56
+#: AKSubmission/templates/AKSubmission/submit_new.html:103
 msgid "Cancel"
 msgstr "Abbrechen"
 
@@ -390,8 +386,8 @@ msgstr "Ich leite bisher keine AKs"
 
 #: AKSubmission/templates/AKSubmission/submission_overview.html:67
 #: AKSubmission/templates/AKSubmission/submit_new.html:9
-#: AKSubmission/templates/AKSubmission/submit_new.html:34
-#: AKSubmission/templates/AKSubmission/submit_new.html:41
+#: AKSubmission/templates/AKSubmission/submit_new.html:80
+#: AKSubmission/templates/AKSubmission/submit_new.html:87
 msgid "New AK"
 msgstr "Neuer AK"
 
@@ -405,78 +401,127 @@ msgstr ""
 "Dieses Event is nicht aktiv. Es können keine AKs hinzugefügt oder bearbeitet "
 "werden"
 
-#: AKSubmission/templates/AKSubmission/submit_new.html:48
+#: AKSubmission/templates/AKSubmission/submit_new.html:68
+msgid ""
+"only relevant for KIF-AKs - determines whether the AK appears in the slides "
+"for the closing plenary session"
+msgstr ""
+"nur relevant für KIF-AKs - entscheidet, ob der AK in den Folien fürs "
+"Abschlussplenum auftaucht"
+
+#: AKSubmission/templates/AKSubmission/submit_new.html:95
 msgid "Submit"
 msgstr "Eintragen"
 
-#: AKSubmission/views.py:73
+#: AKSubmission/templates/AKSubmission/submit_new.html:112
+msgid "Continue with that name?"
+msgstr "Mit dem Namen fortfahren?"
+
+#: AKSubmission/templates/AKSubmission/submit_new.html:116
+msgid ""
+"\n"
+"                    Your AK name (or short name) starts with or contains the "
+"word \"AK\".<br><br>\n"
+"                    This is not recommended, as it makes the names longer, "
+"and may create an inconsistent style.\n"
+"                    The tool will ensure that one always know that a title "
+"belongs to an AK even without that prefix.\n"
+"                    <br><br>\n"
+"                    Do you still want to use that name?\n"
+"                    "
+msgstr ""
+"\n"
+"                    Der Name (oder Kurzname) des AKs beginnt mit dem Wort \"AK\" oder enthält es.<br><br>\n"
+"                    Das ist nicht empfohlen, weil es den Namen länger macht und zu einem inkonsistenten Stil führen kann.\n"
+"                    Das AK-Tool wird dafür sorgen, dass man immer weiß, dass der Titel zu einem AK gehört, auch ohne diesen Prefix.\n"
+"                    <br><br>\n"
+"                    Möchtest du den Namen trotzdem verwenden?\n"
+"                    "
+
+#: AKSubmission/templates/AKSubmission/submit_new.html:125
+msgid "Change name"
+msgstr "Namen ändern"
+
+#: AKSubmission/templates/AKSubmission/submit_new.html:126
+msgid "Proceed with saving"
+msgstr "Mit dem Speichern fortfahren"
+
+#: AKSubmission/views.py:125
 msgid "Wishes"
 msgstr "Wünsche"
 
-#: AKSubmission/views.py:73
+#: AKSubmission/views.py:125
 msgid "AKs one would like to have"
 msgstr ""
 "AKs die sich gewünscht wurden, aber bei denen noch nicht klar ist, wer sie "
 "macht. Falls du dir das vorstellen kannst, trag dich einfach ein"
 
-#: AKSubmission/views.py:93
+#: AKSubmission/views.py:167
 msgid "Currently planned AKs"
 msgstr "Aktuell geplante AKs"
 
-#: AKSubmission/views.py:186
+#: AKSubmission/views.py:235
+msgid "AKs with Track"
+msgstr "AKs mit Track"
+
+#: AKSubmission/views.py:267
+msgid "AKs with Type"
+msgstr "AKs mit Typ"
+
+#: AKSubmission/views.py:337
 msgid "Event inactive. Cannot create or update."
 msgstr "Event inaktiv. Hinzufügen/Bearbeiten nicht möglich."
 
-#: AKSubmission/views.py:202
+#: AKSubmission/views.py:362
 msgid "AK successfully created"
 msgstr "AK erfolgreich angelegt"
 
-#: AKSubmission/views.py:252
+#: AKSubmission/views.py:436
 msgid "AK successfully updated"
 msgstr "AK erfolgreich aktualisiert"
 
-#: AKSubmission/views.py:290
+#: AKSubmission/views.py:487
 #, python-brace-format
 msgid "Added '{owner}' as new owner of '{ak.name}'"
 msgstr "'{owner}' als neue Leitung von '{ak.name}' hinzugefügt"
 
-#: AKSubmission/views.py:331
-msgid "Person Info successfully updated"
-msgstr "Personen-Info erfolgreich aktualisiert"
-
-#: AKSubmission/views.py:351
+#: AKSubmission/views.py:590
 msgid "No user selected"
 msgstr "Keine Person ausgewählt"
 
-#: AKSubmission/views.py:378
+#: AKSubmission/views.py:606
+msgid "Person Info successfully updated"
+msgstr "Personen-Info erfolgreich aktualisiert"
+
+#: AKSubmission/views.py:642
 msgid "AK Slot successfully added"
 msgstr "AK-Slot erfolgreich angelegt"
 
-#: AKSubmission/views.py:391
+#: AKSubmission/views.py:661
 msgid "You cannot edit a slot that has already been scheduled"
 msgstr "Bereits geplante AK-Slots können nicht mehr bearbeitet werden"
 
-#: AKSubmission/views.py:401
+#: AKSubmission/views.py:671
 msgid "AK Slot successfully updated"
 msgstr "AK-Slot erfolgreich aktualisiert"
 
-#: AKSubmission/views.py:413
+#: AKSubmission/views.py:689
 msgid "You cannot delete a slot that has already been scheduled"
 msgstr "Bereits geplante AK-Slots können nicht mehr gelöscht werden"
 
-#: AKSubmission/views.py:423
+#: AKSubmission/views.py:699
 msgid "AK Slot successfully deleted"
 msgstr "AK-Slot erfolgreich angelegt"
 
-#: AKSubmission/views.py:430
+#: AKSubmission/views.py:711
 msgid "Messages"
 msgstr "Nachrichten"
 
-#: AKSubmission/views.py:440
+#: AKSubmission/views.py:721
 msgid "Delete all messages"
 msgstr "Alle Nachrichten löschen"
 
-#: AKSubmission/views.py:463
+#: AKSubmission/views.py:748
 msgid "Message to organizers successfully saved"
 msgstr "Nachricht an die Organisator*innen erfolgreich gespeichert"
 

AKSubmission/models.py

@@ -3,14 +3,15 @@ from django.conf import settings
 from django.core.mail import EmailMessage
 from django.db.models.signals import post_save
 from django.dispatch import receiver
-from django.urls import reverse_lazy
 
 from AKModel.models import AKOrgaMessage, AKSlot
 
 
 @receiver(post_save, sender=AKOrgaMessage)
-def orga_message_saved_handler(sender, instance: AKOrgaMessage, created, **kwargs):
-    # React to newly created Orga message by sending an email
+def orga_message_saved_handler(sender, instance: AKOrgaMessage, created, **kwargs): # pylint: disable=unused-argument
+    """
+    React to newly created Orga message by sending an email
+    """
 
     if created and settings.SEND_MAILS:
         host = 'https://' + settings.ALLOWED_HOSTS[0] if len(settings.ALLOWED_HOSTS) > 0 else 'http://127.0.0.1:8000'
@@ -26,10 +27,12 @@ def orga_message_saved_handler(sender, instance: AKOrgaMessage, created, **kwarg
 
 
 @receiver(post_save, sender=AKSlot)
-def slot_created_handler(sender, instance: AKSlot, created, **kwargs):
-    # React to slots that are created after the plan was already published by sending an email
-
-    if created and settings.SEND_MAILS and apps.is_installed("AKPlan") and not instance.event.plan_hidden and instance.room is None and instance.start is None:
+def slot_created_handler(sender, instance: AKSlot, created, **kwargs): # pylint: disable=unused-argument
+    """
+    React to slots that are created after the plan was already published by sending an email
+    """
+    if created and settings.SEND_MAILS and apps.is_installed("AKPlan") \
+            and not instance.event.plan_hidden and instance.room is None and instance.start is None: # pylint: disable=too-many-boolean-expressions,line-too-long
         host = 'https://' + settings.ALLOWED_HOSTS[0] if len(settings.ALLOWED_HOSTS) > 0 else 'http://127.0.0.1:8000'
         url = f"{host}{instance.ak.detail_url}"
 

AKSubmission/templates/AKSubmission/ak_detail.html

@@ -27,6 +27,55 @@
     {% block imports %}
         {% include "AKPlan/plan_akslot.html" %}
 
+        <script type="module">
+          const { createApp } = Vue
+
+          function getCurrentTimestamp() {
+                return Date.now() / 1000
+            }
+
+          createApp({
+            delimiters: ["[[", "]]"],
+            data() {
+              return {
+                  featuredSlot: "{% if featured_slot %}true{% else %}false{% endif %}",
+                  timer: null,
+                  now: getCurrentTimestamp(),
+                  akStart: "{{ featured_slot.start | date:'U' }}",
+                  akEnd: "{{ featured_slot.end | date:'U' }}",
+                  showBoxWithoutJS: false,
+              }
+            },
+            computed: {
+                showFeatured() {
+                    return this.featuredSlot && this.now < this.akEnd
+                },
+                isBefore() {
+                    return this.featuredSlot && this.now < this.akStart
+                },
+                isDuring() {
+                    return this.featuredSlot && this.akStart < this.now && this.now < this.akEnd
+                },
+                timeUntilStart() {
+                    return Math.ceil((this.akStart - this.now) / 60)
+                },
+                timeUntilEnd() {
+                    return Math.floor((this.akEnd - this.now) / 60)
+                }
+            },
+            mounted: function () {
+                if(this.featuredSlot) {
+                    this.timer = setInterval(() => {
+                        this.now = getCurrentTimestamp()
+                    }, 10000)
+                }
+            },
+            beforeUnmount() {
+                clearInterval(this.timer)
+            }
+          }).mount('#app')
+        </script>
+
         <script>
             document.addEventListener('DOMContentLoaded', function () {
                 // CSRF Protection/Authentication
@@ -128,30 +177,28 @@
 
     <h2>{% if ak.wish %}{% trans "AK Wish" %}: {% endif %}{{ ak.name }}</h2>
 
-    {# Show current or upcoming slot featured in a box on top of the plage #}
-    {% if featured_slot_type != "NONE" %}
-        <div class="card border-success mt-3 mb-3">
-            <div class="card-body font-weight-bold">
-                {% if featured_slot_type == "CURRENT" %}
-                    {% blocktrans with room=featured_slot.room %}
-                        This AK currently takes place for another {{ featured_slot_remaining }} minute(s) in {{ room }}.
-                        &nbsp;
-                    {% endblocktrans %}
-
-                {% elif featured_slot_type == "UPCOMING" %}
-                    {% blocktrans with room=featured_slot.room %}
-                        This AK starts in {{ featured_slot_remaining }} minute(s) in {{ room }}.&nbsp;
-                    {% endblocktrans %}
-                {% endif %}
+    <div id="app">
+        {# Show current or upcoming slot featured in a box on top of the plage #}
+        {% if featured_slot_type != "NONE" %}
+            <div class="card border-success mt-3 mb-3" v-show="showFeatured">
+                <div class="card-body font-weight-bold">
+                    <span v-show="isDuring" style="{% if not featured_slot_type == "CURRENT" %}display:none;{% endif %}">
+                        {% blocktrans with room=featured_slot.room %}This AK currently takes place for another <span v-html="timeUntilEnd">{{ featured_slot_remaining }}</span> minute(s) in {{ room }}.&nbsp;{% endblocktrans %}
+                    </span>
+                    <span v-show="isBefore" style="{% if not featured_slot_type == "UPCOMING" %}display:none;{% endif %}">
+                        {% blocktrans with room=featured_slot.room %}This AK starts in <span v-html="timeUntilStart">{{ featured_slot_remaining }}</span> minute(s) in {{ room }}.&nbsp;{% endblocktrans %}
+                    </span>
 
-                {% if "AKOnline"|check_app_installed and featured_slot.room.virtual and featured_slot.room.virtual.url != '' %}
-                    <a class="btn btn-success" target="_parent" href="{{ featured_slot.room.virtual.url }}">
-                        {% fa6_icon 'external-link-alt' 'fas' %} {% trans "Go to virtual room" %}
-                    </a>
-                {% endif %}
+                    {% if "AKOnline"|check_app_installed and featured_slot.room.virtual and featured_slot.room.virtual.url != '' %}
+                        <a class="btn btn-success" target="_parent" href="{{ featured_slot.room.virtual.url }}">
+                            {% fa6_icon 'external-link-alt' 'fas' %} {% trans "Go to virtual room" %}
+                        </a>
+                    {% endif %}
+                </div>
             </div>
-        </div>
-    {% endif %}
+        {% endif %}
+    </div>
+
 
     <table class="table table-borderless">
         <tr>
@@ -166,6 +213,16 @@
                 {% category_linked_badge ak.category ak.event.slug %}
             </td>
         </tr>
+        {% if ak.types.count > 0 %}
+            <tr>
+                <td>{% trans "Types" %}</td>
+                <td>
+                    {% for type in ak.types.all %}
+                        <span class="badge bg-info">{{ type }}</span>
+                    {% endfor %}
+                </td>
+            </tr>
+        {% endif %}
         {% if ak.track %}
             <tr>
                 <td>{% trans 'Track' %}</td>

AKSubmission/templates/AKSubmission/ak_list.html

@@ -18,6 +18,19 @@
                 </div>
             </li>
         {% endif %}
+        {% if show_types %}
+            <li class="nav-item dropdown">
+                <a class="nav-link dropdown-toggle" data-bs-toggle="dropdown" href="#" role="button" aria-haspopup="true"
+                   aria-expanded="false">{% trans "Types" %}</a>
+                <div class="dropdown-menu" style="">
+                    {% for type in event.aktype_set.all %}
+                        <a class="dropdown-item"
+                           href="{% url 'submit:ak_list_by_type' event_slug=event.slug type_slug=type.slug %}">
+                            {{ type }}</a>
+                    {% endfor %}
+                </div>
+            </li>
+        {% endif %}
     </ul>
 </div>
 

AKSubmission/templates/AKSubmission/ak_table.html

@@ -9,6 +9,9 @@
         <th>{% trans "Name" %}</th>
         <th>{% trans "Who?" %}</th>
         <th>{% trans 'Category' %}</th>
+        {% if show_types %}
+            <th>{% trans 'Types' %}</th>
+        {% endif %}
         <th></th>
     </tr>
     </thead>
@@ -37,6 +40,13 @@
                 {% endif %}
             </td>
             <td>{% category_linked_badge ak.category event.slug %}</td>
+            {% if show_types %}
+                <td>
+                    {% for aktype in ak.types.all %}
+                        {% type_linked_badge aktype event.slug %}
+                    {% endfor %}
+                </td>
+            {% endif %}
             <td class="text-end" style="white-space: nowrap;">
                 <a href="{{ ak.detail_url }}" data-bs-toggle="tooltip"
                    title="{% trans 'Details' %}"

AKSubmission/templates/AKSubmission/submission_overview.html

@@ -26,6 +26,10 @@
         .select2-selection {
           height: 34px !important;
         }
+
+        .select2-container {
+            width: 300px!important;
+        }
     </style>
 
     {% include "AKSubmission/ak_interest_script.html" %}