.docker/extra_requirements.txt

-uwsgi==2.0.28
+uwsgi==2.0.29

.gitlab-ci.yml

@@ -37,7 +37,7 @@ test:
   script:
     - source venv/bin/activate
     - echo "GRANT ALL on *.* to '${MYSQL_USER}';"| mysql -u root --password="${MYSQL_ROOT_PASSWORD}" -h mysql
-    - pip install pytest-cov unittest-xml-reporting
+    - pip install pytest-cov
     - coverage run --source='.' manage.py test --settings AKPlanning.settings_ci
   after_script:
     - source venv/bin/activate

AKDashboard/tests.py

@@ -7,7 +7,7 @@ from django.utils.timezone import now
 
 from AKDashboard.models import DashboardButton
 from AKModel.models import AK, AKCategory, Event
-from AKModel.tests import BasicViewTests
+from AKModel.tests.test_views import BasicViewTests
 
 
 class DashboardTests(TestCase):

AKModel/availability/forms.py

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

AKModel/availability/models.py

@@ -151,9 +151,12 @@ class Availability(models.Model):
         if not other.overlaps(self, strict=False):
             raise Exception('Only overlapping Availabilities can be merged.')
 
-        return Availability(
+        avail = Availability(
             start=min(self.start, other.start), end=max(self.end, other.end)
         )
+        if self.event == other.event:
+            avail.event = self.event
+        return avail
 
     def __or__(self, other: 'Availability') -> 'Availability':
         """Performs the merge operation: ``availability1 | availability2``"""
@@ -168,9 +171,12 @@ class Availability(models.Model):
         if not other.overlaps(self, False):
             raise Exception('Only overlapping Availabilities can be intersected.')
 
-        return Availability(
+        avail = Availability(
             start=max(self.start, other.start), end=min(self.end, other.end)
         )
+        if self.event == other.event:
+            avail.event = self.event
+        return avail
 
     def __and__(self, other: 'Availability') -> 'Availability':
         """Performs the intersect operation: ``availability1 &
@@ -247,7 +253,14 @@ class Availability(models.Model):
                 f'{self.end.astimezone(self.event.timezone).strftime("%a %H:%M")}')
 
     @classmethod
-    def with_event_length(cls, event, person=None, room=None, ak=None, ak_category=None):
+    def with_event_length(
+        cls,
+        event: Event,
+        person: AKOwner | None = None,
+        room: Room | None = None,
+        ak: AK | None = None,
+        ak_category: AKCategory | None = None,
+    ) -> "Availability":
         """
         Create an availability covering exactly the time between event start and event end.
         Can e.g., be used to create default availabilities.
@@ -267,6 +280,30 @@ class Availability(models.Model):
         return Availability(start=timeframe_start, end=timeframe_end, event=event, person=person,
                                     room=room, ak=ak, ak_category=ak_category)
 
+    def is_covered(self, availabilities: List['Availability']):
+        """Check if list of availibilities cover this object.
+
+        :param availabilities: availabilities to check.
+        :return: whether the availabilities cover full event.
+        :rtype: bool
+        """
+        avail_union = Availability.union(availabilities)
+        return any(avail.contains(self) for avail in avail_union)
+
+    @classmethod
+    def is_event_covered(cls, event: Event, availabilities: List['Availability']) -> bool:
+        """Check if list of availibilities cover whole event.
+
+        :param event: event to check.
+        :param availabilities: availabilities to check.
+        :return: whether the availabilities cover full event.
+        :rtype: bool
+        """
+        # NOTE: Cannot use `Availability.with_event_length` as its end is the
+        #       event end + 1 day
+        full_event = Availability(event=event, start=event.start, end=event.end)
+        return full_event.is_covered(availabilities)
+
     class Meta:
         verbose_name = _('Availability')
         verbose_name_plural = _('Availabilities')

AKModel/fixtures/model.json

@@ -93,7 +93,7 @@
     "model": "AKModel.akcategory",
     "pk": 1,
     "fields": {
-        "name": "Spa▀",
+        "name": "Spaß",
         "color": "275246",
         "description": "",
         "present_by_default": true,
@@ -115,7 +115,7 @@
     "model": "AKModel.akcategory",
     "pk": 3,
     "fields": {
-        "name": "Spa▀/Kultur",
+        "name": "Spaß/Kultur",
         "color": "333333",
         "description": "",
         "present_by_default": true,
@@ -437,6 +437,62 @@
         ]
     }
 },
+{
+    "model": "AKModel.ak",
+    "pk": 4,
+    "fields": {
+        "name": "Test AK fixed slots",
+        "short_name": "testfixed",
+        "description": "",
+        "link": "",
+        "protocol_link": "",
+        "category": 4,
+        "track": null,
+        "reso": false,
+        "present": true,
+        "notes": "",
+        "interest": -1,
+        "interest_counter": 0,
+        "include_in_export": false,
+        "event": 2,
+        "owners": [
+            1
+        ],
+        "requirements": [
+            3
+        ],
+        "conflicts": [],
+        "prerequisites": []
+    }
+},
+{
+    "model": "AKModel.ak",
+    "pk": 5,
+    "fields": {
+        "name": "Test AK Ernst",
+        "short_name": "testernst",
+        "description": "",
+        "link": "",
+        "protocol_link": "",
+        "category": 2,
+        "track": null,
+        "reso": false,
+        "present": true,
+        "notes": "",
+        "interest": -1,
+        "interest_counter": 0,
+        "include_in_export": false,
+        "event": 1,
+        "owners": [
+            3
+        ],
+        "requirements": [
+            2
+        ],
+        "conflicts": [],
+        "prerequisites": []
+    }
+},
 {
     "model": "AKModel.room",
     "pk": 1,
@@ -461,6 +517,19 @@
         "properties": []
     }
 },
+{
+    "model": "AKModel.room",
+    "pk": 3,
+    "fields": {
+        "name": "BBB Session 1",
+        "location": "",
+        "capacity": -1,
+        "event": 1,
+        "properties": [
+            2
+        ]
+    }
+},
 {
     "model": "AKModel.akslot",
     "pk": 1,
@@ -526,6 +595,58 @@
         "updated": "2022-12-02T12:23:11.856Z"
     }
 },
+{
+    "model": "AKModel.akslot",
+    "pk": 6,
+    "fields": {
+        "ak": 4,
+        "room": null,
+        "start": "2020-11-08T18:30:00Z",
+        "duration": "2.00",
+        "fixed": true,
+        "event": 2,
+        "updated": "2022-12-02T12:23:11.856Z"
+    }
+},
+{
+    "model": "AKModel.akslot",
+    "pk": 7,
+    "fields": {
+        "ak": 4,
+        "room": 2,
+        "start": null,
+        "duration": "2.00",
+        "fixed": true,
+        "event": 2,
+        "updated": "2022-12-02T12:23:11.856Z"
+    }
+},
+{
+    "model": "AKModel.akslot",
+    "pk": 8,
+    "fields": {
+        "ak": 4,
+        "room": 2,
+        "start": "2020-11-07T16:00:00Z",
+        "duration": "2.00",
+        "fixed": true,
+        "event": 2,
+        "updated": "2022-12-02T12:23:11.856Z"
+    }
+},
+{
+    "model": "AKModel.akslot",
+    "pk": 9,
+    "fields": {
+        "ak": 5,
+        "room": null,
+        "start": null,
+        "duration": "2.00",
+        "fixed": false,
+        "event": 1,
+        "updated": "2022-12-02T12:23:11.856Z"
+    }
+},
 {
     "model": "AKModel.constraintviolation",
     "pk": 1,
@@ -669,5 +790,71 @@
         "start": "2020-11-07T18:30:00Z",
         "end": "2020-11-07T21:30:00Z"
     }
+},
+{
+    "model": "AKModel.availability",
+    "pk": 7,
+    "fields": {
+        "event": 1,
+        "person": null,
+        "room": null,
+        "ak": 5,
+        "ak_category": null,
+        "start": "2020-10-01T17:41:22Z",
+        "end": "2020-10-04T17:41:30Z"
+    }
+},
+{
+    "model": "AKModel.availability",
+    "pk": 8,
+    "fields": {
+        "event": 1,
+        "person": null,
+        "room": 3,
+        "ak": null,
+        "ak_category": null,
+        "start": "2020-10-01T17:41:22Z",
+        "end": "2020-10-04T17:41:30Z"
+    }
+},
+{
+    "model": "AKModel.defaultslot",
+    "pk": 1,
+    "fields": {
+        "event": 2,
+        "start": "2020-11-07T08:00:00Z",
+        "end": "2020-11-07T12:00:00Z",
+        "primary_categories": [5]
+    }
+},
+{
+    "model": "AKModel.defaultslot",
+    "pk": 2,
+    "fields": {
+        "event": 2,
+        "start": "2020-11-07T14:00:00Z",
+        "end": "2020-11-07T17:00:00Z",
+        "primary_categories": [4]
+    }
+},
+{
+    "model": "AKModel.defaultslot",
+    "pk": 3,
+    "fields": {
+        "event": 2,
+        "start": "2020-11-08T08:00:00Z",
+        "end": "2020-11-08T19:00:00Z",
+        "primary_categories": [4, 5]
+    }
+},
+{
+    "model": "AKModel.defaultslot",
+    "pk": 4,
+    "fields": {
+        "event": 2,
+        "start": "2020-11-09T17:00:00Z",
+        "end": "2020-11-10T01:00:00Z",
+        "primary_categories": [4, 5, 3]
+    }
 }
 ]

AKModel/forms.py

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

AKModel/locale/de_DE/LC_MESSAGES/django.po

@@ -281,6 +281,39 @@ msgstr "Standardverfügbarkeiten für alle Räume anlegen?"
 msgid "CSV must contain a name column"
 msgstr "CSV muss eine name-Spalte enthalten"
 
+#: AKModel/forms.py:281
+msgid "JSON data"
+msgstr "JSON-Daten"
+
+#: AKModel/forms.py:282
+msgid "JSON data from the scheduling solver"
+msgstr "JSON-Daten, die der scheduling-solver produziert hat"
+
+#: AKModel/forms.py:299
+msgid "File with JSON data"
+msgstr "Datei mit JSON-Daten"
+
+#: AKModel/forms.py:300
+msgid "File with JSON data from the scheduling solver"
+msgstr "Datei mit JSON-Daten, die der scheduling-solver produziert hat"
+
+#: AKModel/forms.py:307
+msgid "Cannot decode as JSON"
+msgstr "Dekodierung als JSON fehlgeschlagen"
+
+#: AKModel/forms.py:311
+#, python-format
+msgid "Invalid JSON format: %(msg)s at %(error_path)s"
+msgstr "Ungültige JSON-Eingabe: %(msg)s bei %(error_path)s"
+
+#: AKModel/forms.py:321
+msgid "Please enter data as a file OR via text, not both."
+msgstr "Gib die Daten bitte als Datei oder als Text ein, nicht beides."
+
+#: AKModel/forms.py:327
+msgid "No data entered. Please enter data as a file or via text."
+msgstr "Keine Daten eingegeben. Gib die Daten bitte als Datei oder als Text ein."
+
 #: AKModel/metaviews/admin.py:156 AKModel/models.py:40
 msgid "Start"
 msgstr "Start"
@@ -442,7 +475,19 @@ msgstr "Standardslotlänge"
 msgid "Default length in hours that is assumed for AKs in this event."
 msgstr "Standardlänge von Slots (in Stunden) für dieses Event"
 
-#: AKModel/models.py:66
+#: AKModel/models.py:154
+msgid "Export Slot Length"
+msgstr "Export-Slotlänge"
+
+#: AKModel/models.py:156
+msgid ""
+"Slot duration in hours that is used in the timeslot discretization, when "
+"this event is exported for the solver."
+msgstr ""
+"Länge von Slots (in Stunden) in der Zeitslot-Diskretisierung beim "
+"JSON-Export dieses Events."
+
+#: AKModel/models.py:161
 msgid "Contact email address"
 msgstr "E-Mail Kontaktadresse"
 
@@ -458,6 +503,46 @@ msgstr ""
 msgid "Events"
 msgstr "Events"
 
+#: AKModel/models.py:427
+msgid "Cannot parse malformed JSON input."
+msgstr "Kann fehlerhafte JSON-Eingabe nicht verarbeiten"
+
+#: AKModel/models.py:430
+msgid "Data has changed since the export. Reexport and run the solver again."
+msgstr "Seit dem Export wurden die Daten verändert. Wiederhole den Export und führe den Solver erneut aus."
+
+#: AKModel/models.py:430
+#, python-brace-format
+msgid "AK {ak_name} is not assigned any timeslot by the solver"
+msgstr "Dem AK {ak_name} wurde vom Solver kein Zeitslot zugewiesen"
+
+#: AKModel/models.py:440
+#, python-brace-format
+msgid ""
+"Duration of AK {ak_name} assigned by solver ({solver_duration} hours) is "
+"less than the duration required by the slot ({slot_duration} hours)"
+msgstr ""
+"Die dem AK {ak_name} vom Solver zugewiesene Dauer ({solver_duration} Stunden) ist "
+"kürzer als die aktuell vorgesehene Dauer des Slots ({slot_duration} Stunden)"
+
+#: AKModel/models.py:454
+#, python-brace-format
+msgid ""
+"Fixed AK {ak_name} assigned by solver to room {solver_room} is fixed to room "
+"{slot_room}"
+msgstr ""
+"Dem fix geplanten AK {ak_name} wurde vom Solver Raum {solver_room} zugewiesen, "
+"dabei ist der AK bereits fix in Raum {slot_room} eingeplant."
+
+#: AKModel/models.py:465
+#, python-brace-format
+msgid ""
+"Fixed AK {ak_name} assigned by solver to start at {solver_start} is fixed to "
+"start at {slot_start}"
+msgstr ""
+"Dem fix geplanten AK {ak_name} wurde vom Solver die Startzeit {solver_start} zugewiesen, "
+"dabei ist der AK bereits für {slot_start} eingeplant."
+
 #: AKModel/models.py:180
 msgid "Nickname"
 msgstr "Spitzname"
@@ -973,7 +1058,15 @@ msgstr "Primäre Kategorien"
 msgid "Categories that should be assigned to this slot primarily"
 msgstr "Kategorieren, die diesem Slot primär zugewiesen werden sollen"
 
-#: AKModel/site.py:14
+#: AKModel/models.py:936
+msgid "Conflicts"
+msgstr "Konflikte"
+
+#: AKModel/models.py:939
+msgid "Prerequisites"
+msgstr "Voraussetzungen"
+
+#: AKModel/site.py:13 AKModel/site.py:14
 msgid "Administration"
 msgstr "Verwaltung"
 
@@ -1184,7 +1277,15 @@ msgstr "Anforderungen für das Event"
 msgid "AK CSV Export"
 msgstr "AK-CSV-Export"
 
-#: AKModel/views/ak.py:48
+#: AKModel/views/ak.py:50
+msgid "AK JSON Export"
+msgstr "AK-JSON-Export"
+
+#: AKModel/views/ak.py:64
+msgid "Exporting AKs for the solver failed! Reason: "
+msgstr "Daten für den Solver exportieren fehlgeschlagen! Grund: "
+
+#: AKModel/views/ak.py:133
 msgid "AK Wiki Export"
 msgstr "AK-Wiki-Export"
 
@@ -1310,6 +1411,19 @@ msgid "Updated {u} slot(s). created {c} new slot(s) and deleted {d} slot(s)"
 msgstr ""
 "{u} Slot(s) aktualisiert, {c} Slot(s) hinzugefügt und {d} Slot(s) gelöscht"
 
+#: AKModel/views/manage.py:257
+msgid "AK Schedule JSON Import"
+msgstr "AK-Plan JSON-Import"
+
+#: AKModel/views/manage.py:265
+#, python-brace-format
+msgid "Successfully imported {n} slot(s)"
+msgstr "Erfolgreich {n} Slot(s) importiert"
+
+#: AKModel/views/manage.py:271
+msgid "Importing an AK schedule failed! Reason: "
+msgstr "AK-Plan importieren fehlgeschlagen! Grund: "
+
 #: AKModel/views/room.py:37
 #, python-format
 msgid "Created Room '%(room)s'"
@@ -1361,10 +1475,18 @@ msgstr "Interesse erfassen"
 msgid "Manage ak tracks"
 msgstr "AK-Tracks verwalten"
 
+#: AKModel/views/status.py:142
+msgid "Import AK schedule from JSON"
+msgstr "AK-Plan aus JSON importieren"
+
 #: AKModel/views/status.py:142
 msgid "Export AKs as CSV"
 msgstr "AKs als CSV exportieren"
 
+#: AKModel/views/status.py:145
+msgid "Export AKs as JSON"
+msgstr "AKs als JSON exportieren"
+
 #: AKModel/views/status.py:146
 msgid "Export AKs for Wiki"
 msgstr "AKs im Wiki-Format exportieren"
@@ -1377,6 +1499,10 @@ msgstr "Zu Anforderungen gehörige AKs anzeigen"
 msgid "Event Status"
 msgstr "Eventstatus"
 
+#, python-format
+#~ msgid "Invalid JSON format: field '%(field)s' is missing"
+#~ msgstr "Ungültige JSON-Eingabe: das Feld '%(field)s' fehlt"
+
 #~ msgid "Opening time for expression of interest."
 #~ msgstr "Öffnungszeitpunkt für die Angabe von Interesse an AKs."
 

AKModel/migrations/0064_event_export_slot.py

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

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

AKModel/templates/admin/AKModel/import_json.html

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

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

@@ -7,8 +7,19 @@ from django.contrib.messages.storage.base import Message
 from django.test import TestCase
 from django.urls import reverse_lazy, reverse
 
-from AKModel.models import Event, AKOwner, AKCategory, AKTrack, AKRequirement, AK, Room, AKSlot, AKOrgaMessage, \
-    ConstraintViolation, DefaultSlot
+from AKModel.models import (
+    Event,
+    AKOwner,
+    AKCategory,
+    AKTrack,
+    AKRequirement,
+    AK,
+    Room,
+    AKSlot,
+    AKOrgaMessage,
+    ConstraintViolation,
+    DefaultSlot,
+)
 
 
 class BasicViewTests:
@@ -29,9 +40,10 @@ class BasicViewTests:
     since the test framework does not understand the concept of abstract test definitions and would handle this class
     as real test case otherwise, distorting the test results.
     """
+
     # pylint: disable=no-member
     VIEWS = []
-    APP_NAME = ''
+    APP_NAME = ""
     VIEWS_STAFF_ONLY = []
     EDIT_TESTCASES = []
 
@@ -41,16 +53,26 @@ class BasicViewTests:
         """
         user_model = get_user_model()
         self.staff_user = user_model.objects.create(
-            username='Test Staff User', email='teststaff@example.com', password='staffpw',
-            is_staff=True, is_active=True
+            username="Test Staff User",
+            email="teststaff@example.com",
+            password="staffpw",
+            is_staff=True,
+            is_active=True,
         )
         self.admin_user = user_model.objects.create(
-            username='Test Admin User', email='testadmin@example.com', password='adminpw',
-            is_staff=True, is_superuser=True, is_active=True
+            username="Test Admin User",
+            email="testadmin@example.com",
+            password="adminpw",
+            is_staff=True,
+            is_superuser=True,
+            is_active=True,
         )
         self.deactivated_user = user_model.objects.create(
-            username='Test Deactivated User', email='testdeactivated@example.com', password='deactivatedpw',
-            is_staff=True, is_active=False
+            username="Test Deactivated User",
+            email="testdeactivated@example.com",
+            password="deactivatedpw",
+            is_staff=True,
+            is_active=False,
         )
 
     def _name_and_url(self, view_name):
@@ -62,7 +84,9 @@ class BasicViewTests:
         :return: full view name with prefix if applicable, url of the view
         :rtype: str, str
         """
-        view_name_with_prefix = f"{self.APP_NAME}:{view_name[0]}" if self.APP_NAME != "" else view_name[0]
+        view_name_with_prefix = (
+            f"{self.APP_NAME}:{view_name[0]}" if self.APP_NAME != "" else view_name[0]
+        )
         url = reverse(view_name_with_prefix, kwargs=view_name[1])
         return view_name_with_prefix, url
 
@@ -74,7 +98,7 @@ class BasicViewTests:
         :param expected_message: message that should be shown
         :param msg_prefix: prefix for the error message when test fails
         """
-        messages:List[Message] = list(get_messages(response.wsgi_request))
+        messages: List[Message] = list(get_messages(response.wsgi_request))
 
         msg_count = "No message shown to user"
         msg_content = "Wrong message, expected '{expected_message}'"
@@ -95,10 +119,16 @@ class BasicViewTests:
             view_name_with_prefix, url = self._name_and_url(view_name)
             try:
                 response = self.client.get(url)
-                self.assertEqual(response.status_code, 200, msg=f"{view_name_with_prefix} ({url}) broken")
-            except Exception: # pylint: disable=broad-exception-caught
-                self.fail(f"An error occurred during rendering of {view_name_with_prefix} ({url}):"
-                          f"\n\n{traceback.format_exc()}")
+                self.assertEqual(
+                    response.status_code,
+                    200,
+                    msg=f"{view_name_with_prefix} ({url}) broken",
+                )
+            except Exception:  # pylint: disable=broad-exception-caught
+                self.fail(
+                    f"An error occurred during rendering of {view_name_with_prefix} ({url}):"
+                    f"\n\n{traceback.format_exc()}"
+                )
 
     def test_access_control_staff_only(self):
         """
@@ -107,11 +137,16 @@ class BasicViewTests:
         # Not logged in? Views should not be visible
         self.client.logout()
         for view_name_info in self.VIEWS_STAFF_ONLY:
-            expected_response_code = 302 if len(view_name_info) == 2 else view_name_info[2]
+            expected_response_code = (
+                302 if len(view_name_info) == 2 else view_name_info[2]
+            )
             view_name_with_prefix, url = self._name_and_url(view_name_info)
             response = self.client.get(url)
-            self.assertEqual(response.status_code, expected_response_code,
-                             msg=f"{view_name_with_prefix} ({url}) accessible by non-staff")
+            self.assertEqual(
+                response.status_code,
+                expected_response_code,
+                msg=f"{view_name_with_prefix} ({url}) accessible by non-staff",
+            )
 
         # Logged in? Views should be visible
         self.client.force_login(self.staff_user)
@@ -119,20 +154,30 @@ class BasicViewTests:
             view_name_with_prefix, url = self._name_and_url(view_name_info)
             try:
                 response = self.client.get(url)
-                self.assertEqual(response.status_code, 200,
-                                 msg=f"{view_name_with_prefix} ({url}) should be accessible for staff (but isn't)")
+                self.assertEqual(
+                    response.status_code,
+                    200,
+                    msg=f"{view_name_with_prefix} ({url}) should be accessible for staff (but isn't)",
+                )
             except Exception:  # pylint: disable=broad-exception-caught
-                self.fail(f"An error occurred during rendering of {view_name_with_prefix} ({url}):"
-                          f"\n\n{traceback.format_exc()}")
+                self.fail(
+                    f"An error occurred during rendering of {view_name_with_prefix} ({url}):"
+                    f"\n\n{traceback.format_exc()}"
+                )
 
         # Disabled user? Views should not be visible
         self.client.force_login(self.deactivated_user)
         for view_name_info in self.VIEWS_STAFF_ONLY:
-            expected_response_code = 302 if len(view_name_info) == 2 else view_name_info[2]
+            expected_response_code = (
+                302 if len(view_name_info) == 2 else view_name_info[2]
+            )
             view_name_with_prefix, url = self._name_and_url(view_name_info)
             response = self.client.get(url)
-            self.assertEqual(response.status_code, expected_response_code,
-                             msg=f"{view_name_with_prefix} ({url}) still accessible for deactivated user")
+            self.assertEqual(
+                response.status_code,
+                expected_response_code,
+                msg=f"{view_name_with_prefix} ({url}) still accessible for deactivated user",
+            )
 
     def _to_sendable_value(self, val):
         """
@@ -182,16 +227,26 @@ class BasicViewTests:
             self.client.logout()
 
         response = self.client.get(url)
-        self.assertEqual(response.status_code, 200, msg=f"{name}: Could not load edit form via GET ({url})")
+        self.assertEqual(
+            response.status_code,
+            200,
+            msg=f"{name}: Could not load edit form via GET ({url})",
+        )
 
         form = response.context[form_name]
-        data = {k:self._to_sendable_value(v) for k,v in form.initial.items()}
+        data = {k: self._to_sendable_value(v) for k, v in form.initial.items()}
 
         response = self.client.post(url, data=data)
         if expected_code == 200:
-            self.assertEqual(response.status_code, 200, msg=f"{name}: Did not return 200 ({url}")
+            self.assertEqual(
+                response.status_code, 200, msg=f"{name}: Did not return 200 ({url}"
+            )
         elif expected_code == 302:
-            self.assertRedirects(response, target_url, msg_prefix=f"{name}: Did not redirect ({url} -> {target_url}")
+            self.assertRedirects(
+                response,
+                target_url,
+                msg_prefix=f"{name}: Did not redirect ({url} -> {target_url}",
+            )
         if expected_message != "":
             self._assert_message(response, expected_message, msg_prefix=f"{name}")
 
@@ -200,30 +255,44 @@ class ModelViewTests(BasicViewTests, TestCase):
     """
     Basic view test cases for views from AKModel plus some custom tests
     """
-    fixtures = ['model.json']
+
+    fixtures = ["model.json"]
 
     ADMIN_MODELS = [
-        (Event, 'event'), (AKOwner, 'akowner'), (AKCategory, 'akcategory'), (AKTrack, 'aktrack'),
-        (AKRequirement, 'akrequirement'), (AK, 'ak'), (Room, 'room'), (AKSlot, 'akslot'),
-        (AKOrgaMessage, 'akorgamessage'), (ConstraintViolation, 'constraintviolation'),
-        (DefaultSlot, 'defaultslot')
+        (Event, "event"),
+        (AKOwner, "akowner"),
+        (AKCategory, "akcategory"),
+        (AKTrack, "aktrack"),
+        (AKRequirement, "akrequirement"),
+        (AK, "ak"),
+        (Room, "room"),
+        (AKSlot, "akslot"),
+        (AKOrgaMessage, "akorgamessage"),
+        (ConstraintViolation, "constraintviolation"),
+        (DefaultSlot, "defaultslot"),
     ]
 
     VIEWS_STAFF_ONLY = [
-        ('admin:index', {}),
-        ('admin:event_status', {'event_slug': 'kif42'}),
-        ('admin:event_requirement_overview', {'event_slug': 'kif42'}),
-        ('admin:ak_csv_export', {'event_slug': 'kif42'}),
-        ('admin:ak_wiki_export', {'slug': 'kif42'}),
-        ('admin:ak_delete_orga_messages', {'event_slug': 'kif42'}),
-        ('admin:ak_slide_export', {'event_slug': 'kif42'}),
-        ('admin:default-slots-editor', {'event_slug': 'kif42'}),
-        ('admin:room-import', {'event_slug': 'kif42'}),
-        ('admin:new_event_wizard_start', {}),
+        ("admin:index", {}),
+        ("admin:event_status", {"event_slug": "kif42"}),
+        ("admin:event_requirement_overview", {"event_slug": "kif42"}),
+        ("admin:ak_csv_export", {"event_slug": "kif42"}),
+        ("admin:ak_json_export", {"event_slug": "kif42"}),
+        ("admin:ak_wiki_export", {"slug": "kif42"}),
+        ("admin:ak_schedule_json_import", {"event_slug": "kif42"}),
+        ("admin:ak_delete_orga_messages", {"event_slug": "kif42"}),
+        ("admin:ak_slide_export", {"event_slug": "kif42"}),
+        ("admin:default-slots-editor", {"event_slug": "kif42"}),
+        ("admin:room-import", {"event_slug": "kif42"}),
+        ("admin:new_event_wizard_start", {}),
     ]
 
     EDIT_TESTCASES = [
-        {'view': 'admin:default-slots-editor', 'kwargs': {'event_slug': 'kif42'}, "admin": True},
+        {
+            "view": "admin:default-slots-editor",
+            "kwargs": {"event_slug": "kif42"},
+            "admin": True,
+        },
     ]
 
     def test_admin(self):
@@ -234,24 +303,32 @@ class ModelViewTests(BasicViewTests, TestCase):
         for model in self.ADMIN_MODELS:
             # Special treatment for a subset of views (where we exchanged default functionality, e.g., create views)
             if model[1] == "event":
-                _, url = self._name_and_url(('admin:new_event_wizard_start', {}))
+                _, url = self._name_and_url(("admin:new_event_wizard_start", {}))
             elif model[1] == "room":
-                _, url = self._name_and_url(('admin:room-new', {}))
+                _, url = self._name_and_url(("admin:room-new", {}))
             # Otherwise, just call the creation form view
             else:
-                _, url = self._name_and_url((f'admin:AKModel_{model[1]}_add', {}))
+                _, url = self._name_and_url((f"admin:AKModel_{model[1]}_add", {}))
             response = self.client.get(url)
-            self.assertEqual(response.status_code, 200, msg=f"Add form for model {model[1]} ({url}) broken")
+            self.assertEqual(
+                response.status_code,
+                200,
+                msg=f"Add form for model {model[1]} ({url}) broken",
+            )
 
         for model in self.ADMIN_MODELS:
             # Test the update view using the first existing instance of each model
             m = model[0].objects.first()
             if m is not None:
                 _, url = self._name_and_url(
-                    (f'admin:AKModel_{model[1]}_change', {'object_id': m.pk})
+                    (f"admin:AKModel_{model[1]}_change", {"object_id": m.pk})
                 )
                 response = self.client.get(url)
-                self.assertEqual(response.status_code, 200, msg=f"Edit form for model {model[1]} ({url}) broken")
+                self.assertEqual(
+                    response.status_code,
+                    200,
+                    msg=f"Edit form for model {model[1]} ({url}) broken",
+                )
 
     def test_wiki_export(self):
         """
@@ -260,17 +337,27 @@ class ModelViewTests(BasicViewTests, TestCase):
         """
         self.client.force_login(self.admin_user)
 
-        export_url = reverse_lazy("admin:ak_wiki_export", kwargs={'slug': 'kif42'})
+        export_url = reverse_lazy("admin:ak_wiki_export", kwargs={"slug": "kif42"})
         response = self.client.get(export_url)
         self.assertEqual(response.status_code, 200, "Export not working at all")
 
         export_count = 0
         for _, aks in response.context["categories_with_aks"]:
             for ak in aks:
-                self.assertEqual(ak.include_in_export, True,
-                                 f"AK with export flag set to False (pk={ak.pk}) included in export")
-                self.assertNotEqual(ak.pk, 1, "AK known to be excluded from export (PK 1) included in export")
+                self.assertEqual(
+                    ak.include_in_export,
+                    True,
+                    f"AK with export flag set to False (pk={ak.pk}) included in export",
+                )
+                self.assertNotEqual(
+                    ak.pk,
+                    1,
+                    "AK known to be excluded from export (PK 1) included in export",
+                )
                 export_count += 1
 
-        self.assertEqual(export_count, AK.objects.filter(event_id=2, include_in_export=True).count(),
-                         "Wiki export contained the wrong number of AKs")
+        self.assertEqual(
+            export_count,
+            AK.objects.filter(event_id=2, include_in_export=True).count(),
+            "Wiki export contained the wrong number of AKs",
+        )

AKModel/urls.py

@@ -5,8 +5,9 @@ from rest_framework.routers import DefaultRouter
 
 import AKModel.views.api
 from AKModel.views.manage import ExportSlidesView, PlanPublishView, PlanUnpublishView, DefaultSlotEditorView, \
-    AKsByUserView
-from AKModel.views.ak import AKRequirementOverview, AKCSVExportView, AKWikiExportView, AKMessageDeleteView
+    AKsByUserView, AKScheduleJSONImportView
+from AKModel.views.ak import AKRequirementOverview, AKCSVExportView, AKJSONExportView, AKWikiExportView, \
+     AKMessageDeleteView
 from AKModel.views.event_wizard import NewEventWizardStartView, NewEventWizardPrepareImportView, \
     NewEventWizardImportView, NewEventWizardActivateView, NewEventWizardFinishView, NewEventWizardSettingsView
 from AKModel.views.room import RoomBatchCreationView
@@ -96,6 +97,10 @@ def get_admin_urls_event(admin_site):
              name="aks_by_owner"),
         path('<slug:event_slug>/ak-csv-export/', admin_site.admin_view(AKCSVExportView.as_view()),
              name="ak_csv_export"),
+        path('<slug:event_slug>/ak-json-export/', admin_site.admin_view(AKJSONExportView.as_view()),
+             name="ak_json_export"),
+        path('<slug:event_slug>/ak-schedule-json-import/', admin_site.admin_view(AKScheduleJSONImportView.as_view()),
+             name="ak_schedule_json_import"),
         path('<slug:slug>/ak-wiki-export/', admin_site.admin_view(AKWikiExportView.as_view()),
              name="ak_wiki_export"),
         path('<slug:event_slug>/delete-orga-messages/', admin_site.admin_view(AKMessageDeleteView.as_view()),

AKModel/utils.py

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

AKModel/views/ak.py

+import json
+
 from django.contrib import messages
+from django.shortcuts import redirect
 from django.urls import reverse_lazy
 from django.utils.translation import gettext_lazy as _
 from django.views.generic import ListView, DetailView
@@ -37,6 +40,44 @@ class AKCSVExportView(AdminViewMixin, FilterByEventSlugMixin, ListView):
         return super().get_queryset().order_by("ak__track")
 
 
+class AKJSONExportView(AdminViewMixin, DetailView):
+    """
+    View: Export all AK slots of this event in JSON format ordered by tracks
+    """
+    template_name = "admin/AKModel/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:
+            data = context["event"].as_json_dict()
+            context["json_data_oneline"] = json.dumps(data, ensure_ascii=False)
+            context["json_data"] = json.dumps(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 AKWikiExportView(AdminViewMixin, DetailView):
     """
     View: Export AKs of this event in wiki syntax

AKModel/views/manage.py

@@ -4,15 +4,17 @@ import os
 import tempfile
 from itertools import zip_longest
 
+
 from django.contrib import messages
 from django.db.models.functions import Now
+from django.shortcuts import redirect
 from django.utils.dateparse import parse_datetime
 from django.utils.translation import gettext_lazy as _
 from django.views.generic import TemplateView, DetailView
 from django_tex.core import render_template_with_context, run_tex_in_directory
 from django_tex.response import PDFResponse
 
-from AKModel.forms import SlideExportForm, DefaultSlotEditorForm
+from AKModel.forms import SlideExportForm, DefaultSlotEditorForm, JSONScheduleImportForm
 from AKModel.metaviews.admin import EventSlugMixin, IntermediateAdminView, IntermediateAdminActionView, AdminViewMixin
 from AKModel.models import ConstraintViolation, Event, DefaultSlot, AKOwner
 
@@ -58,7 +60,7 @@ class ExportSlidesView(EventSlugMixin, IntermediateAdminView):
             Create a list of tuples cosisting of an AK and a list of upcoming AKs (list length depending on setting)
             """
             next_aks_list = zip_longest(*[ak_list[i + 1:] for i in range(NEXT_AK_LIST_LENGTH)], fillvalue=None)
-            return [(ak, next_aks) for ak, next_aks in zip_longest(ak_list, next_aks_list, fillvalue=[])]
+            return list(zip_longest(ak_list, next_aks_list, fillvalue=[]))
 
         # Get all relevant AKs (wishes separately, and either all AKs or only those who should directly or indirectly
         # be presented when restriction setting was chosen)
@@ -245,3 +247,29 @@ class AKsByUserView(AdminViewMixin, EventSlugMixin, DetailView):
     model = AKOwner
     context_object_name = 'owner'
     template_name = "admin/AKModel/aks_by_user.html"
+
+
+class AKScheduleJSONImportView(EventSlugMixin, IntermediateAdminView):
+    """
+    View: Import an AK schedule from a json file that can be pasted into this view.
+    """
+    template_name = "admin/AKModel/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)

AKModel/views/status.py

@@ -138,10 +138,18 @@ class EventAKsWidget(TemplateStatusWidget):
                     "text": _("Manage ak tracks"),
                     "url": reverse_lazy("admin:tracks_manage", kwargs={"event_slug": context["event"].slug}),
                 },
+                {
+                    "text": _("Import AK schedule from JSON"),
+                    "url": reverse_lazy("admin:ak_schedule_json_import", kwargs={"event_slug": context["event"].slug}),
+                },
                 {
                     "text": _("Export AKs as CSV"),
                     "url": reverse_lazy("admin:ak_csv_export", kwargs={"event_slug": context["event"].slug}),
                 },
+                {
+                    "text": _("Export AKs as JSON"),
+                    "url": reverse_lazy("admin:ak_json_export", kwargs={"event_slug": context["event"].slug}),
+                },
                 {
                     "text": _("Export AKs for Wiki"),
                     "url": reverse_lazy("admin:ak_wiki_export", kwargs={"slug": context["event"].slug}),