AKModel/availability/serializers.py

 # This part of the code was adapted from pretalx (https://github.com/pretalx/pretalx)
 # Copyright 2017-2019, Tobias Kunze
 # Original Copyrights licensed under the Apache License, Version 2.0 http://www.apache.org/licenses/LICENSE-2.0
-# Changes are marked in the code
+# Documentation was mainly added by us, other changes are marked in the code
+from django.utils import timezone
 from rest_framework.fields import SerializerMethodField
 from rest_framework.serializers import ModelSerializer
 
@@ -9,11 +10,37 @@ from AKModel.availability.models import Availability
 
 
 class AvailabilitySerializer(ModelSerializer):
+    """
+    REST Framework Serializer for Availability
+    """
     allDay = SerializerMethodField()
+    start = SerializerMethodField()
+    end = SerializerMethodField()
 
-    def get_allDay(self, obj):
+    def get_allDay(self, obj):  # pylint: disable=invalid-name
+        """
+        Bridge between naming conventions of python and fullcalendar by providing the all_day field as allDay, too
+        """
         return obj.all_day
 
+    def get_start(self, obj):
+        """
+        Get start timestamp
+
+        Use already localized strings in serialized field
+        (default would be UTC, but that would require heavy timezone calculation on client side)
+        """
+        return timezone.localtime(obj.start, obj.event.timezone).strftime("%Y-%m-%dT%H:%M:%S")
+
+    def get_end(self, obj):
+        """
+        Get end timestamp
+
+        Use already localized strings in serialized field
+        (default would be UTC, but that would require heavy timezone calculation on client side)
+        """
+        return timezone.localtime(obj.end, obj.event.timezone).strftime("%Y-%m-%dT%H:%M:%S")
+
     class Meta:
         model = Availability
         fields = ('id', 'start', 'end', 'allDay')

AKModel/environment.py

-# environment.py
+"""
+Environment definitions
+Needed for tex compilation
+"""
 import re
 
 from django_tex.environment import environment
 
 # Used to filter all very special UTF-8 chars that are probably not contained in the LaTeX fonts
 # and would hence cause compilation errors
-utf8_replace_pattern = re.compile(u'[^\u0000-\u206F]', re.UNICODE)
+utf8_replace_pattern = re.compile('[^\u0000-\u206F]', re.UNICODE)
 
 
 def latex_escape_utf8(value):
@@ -17,12 +20,14 @@ def latex_escape_utf8(value):
     :return: escaped string
     :rtype: str
     """
-    return utf8_replace_pattern.sub('', value).replace('&', '\&').replace('_', '\_').replace('#', '\#').replace('$',
-                                                                                                                '\$').replace(
-        '%', '\%').replace('{', '\{').replace('}', '\}')
+    return (utf8_replace_pattern.sub('', value).replace('&', r'\&').replace('_', r'\_').replace('#', r'\#').
+            replace('$', r'\$').replace('%', r'\%').replace('{', r'\{').replace('}', r'\}'))
 
 
 def improved_tex_environment(**options):
+    """
+    Encapsulate our improved latex environment for usage
+    """
     env = environment(**options)
     env.filters.update({
         'latex_escape_utf8': latex_escape_utf8,

AKModel/fixtures/model.json

+[
+{
+    "model": "AKModel.event",
+    "pk": 1,
+    "fields": {
+        "name": "KIF 23",
+        "slug": "kif23",
+        "place": "Neuland",
+        "timezone": "Europe/Berlin",
+        "start": "2020-10-01T17:41:22Z",
+        "end": "2020-10-04T17:41:30Z",
+        "reso_deadline": "2020-10-03T10:00:00Z",
+        "interest_start": null,
+        "interest_end": null,
+        "public": true,
+        "active": false,
+        "plan_hidden": true,
+        "plan_published_at": null,
+        "base_url": "",
+        "wiki_export_template_name": "",
+        "default_slot": "2.00",
+        "contact_email": "dummy@eyample.org"
+    }
+},
+{
+    "model": "AKModel.event",
+    "pk": 2,
+    "fields": {
+        "name": "KIF 42",
+        "slug": "kif42",
+        "place": "Neuland noch neuer",
+        "timezone": "Europe/Berlin",
+        "start": "2020-11-06T17:51:26Z",
+        "end": "2020-11-10T17:51:27Z",
+        "reso_deadline": "2020-11-08T17:51:42Z",
+        "interest_start": null,
+        "interest_end": null,
+        "public": true,
+        "active": true,
+        "plan_hidden": false,
+        "plan_published_at": "2022-12-01T21:50:01Z",
+        "base_url": "",
+        "wiki_export_template_name": "",
+        "default_slot": "2.00",
+        "contact_email": "dummy@example.org"
+    }
+},
+{
+    "model": "AKModel.akowner",
+    "pk": 1,
+    "fields": {
+        "name": "a",
+        "slug": "a",
+        "institution": "Uni X",
+        "link": "",
+        "event": 2
+    }
+},
+{
+    "model": "AKModel.akowner",
+    "pk": 2,
+    "fields": {
+        "name": "b",
+        "slug": "b",
+        "institution": "Hochschule Y",
+        "link": "",
+        "event": 2
+    }
+},
+{
+    "model": "AKModel.akowner",
+    "pk": 3,
+    "fields": {
+        "name": "c",
+        "slug": "c",
+        "institution": "",
+        "link": "",
+        "event": 1
+    }
+},
+{
+    "model": "AKModel.akowner",
+    "pk": 4,
+    "fields": {
+        "name": "d",
+        "slug": "d",
+        "institution": "",
+        "link": "",
+        "event": 1
+    }
+},
+{
+    "model": "AKModel.akcategory",
+    "pk": 1,
+    "fields": {
+        "name": "Spaß",
+        "color": "275246",
+        "description": "",
+        "present_by_default": true,
+        "event": 1
+    }
+},
+{
+    "model": "AKModel.akcategory",
+    "pk": 2,
+    "fields": {
+        "name": "Ernst",
+        "color": "234567",
+        "description": "",
+        "present_by_default": true,
+        "event": 1
+    }
+},
+{
+    "model": "AKModel.akcategory",
+    "pk": 3,
+    "fields": {
+        "name": "Spaß/Kultur",
+        "color": "333333",
+        "description": "",
+        "present_by_default": true,
+        "event": 2
+    }
+},
+{
+    "model": "AKModel.akcategory",
+    "pk": 4,
+    "fields": {
+        "name": "Inhalt",
+        "color": "456789",
+        "description": "",
+        "present_by_default": true,
+        "event": 2
+    }
+},
+{
+    "model": "AKModel.akcategory",
+    "pk": 5,
+    "fields": {
+        "name": "Meta",
+        "color": "111111",
+        "description": "",
+        "present_by_default": true,
+        "event": 2
+    }
+},
+{
+    "model": "AKModel.aktrack",
+    "pk": 1,
+    "fields": {
+        "name": "Track 1",
+        "color": "",
+        "event": 2
+    }
+},
+{
+    "model": "AKModel.akrequirement",
+    "pk": 1,
+    "fields": {
+        "name": "Beamer",
+        "event": 1
+    }
+},
+{
+    "model": "AKModel.akrequirement",
+    "pk": 2,
+    "fields": {
+        "name": "Internet",
+        "event": 1
+    }
+},
+{
+    "model": "AKModel.akrequirement",
+    "pk": 3,
+    "fields": {
+        "name": "BBB",
+        "event": 2
+    }
+},
+{
+    "model": "AKModel.akrequirement",
+    "pk": 4,
+    "fields": {
+        "name": "Mumble",
+        "event": 2
+    }
+},
+{
+    "model": "AKModel.akrequirement",
+    "pk": 5,
+    "fields": {
+        "name": "Matrix",
+        "event": 2
+    }
+},
+{
+    "model": "AKModel.aktype",
+    "pk": 1,
+    "fields": {
+        "name": "Input",
+        "event": 2
+    }
+},
+{
+    "model": "AKModel.historicalak",
+    "pk": 1,
+    "fields": {
+        "id": 1,
+        "name": "Test AK Inhalt",
+        "short_name": "test1",
+        "description": "",
+        "link": "",
+        "protocol_link": "",
+        "reso": false,
+        "present": true,
+        "notes": "",
+        "category": 4,
+        "track": null,
+        "event": 2,
+        "history_date": "2021-05-04T10:28:59.265Z",
+        "history_change_reason": null,
+        "history_type": "+",
+        "history_user": null
+    }
+},
+{
+    "model": "AKModel.historicalak",
+    "pk": 2,
+    "fields": {
+        "id": 1,
+        "name": "Test AK Inhalt",
+        "short_name": "test1",
+        "description": "",
+        "link": "",
+        "protocol_link": "",
+        "reso": false,
+        "present": true,
+        "notes": "",
+        "category": 4,
+        "track": null,
+        "event": 2,
+        "history_date": "2021-05-04T10:28:59.305Z",
+        "history_change_reason": null,
+        "history_type": "~",
+        "history_user": null
+    }
+},
+{
+    "model": "AKModel.historicalak",
+    "pk": 3,
+    "fields": {
+        "id": 2,
+        "name": "Test AK Meta",
+        "short_name": "test2",
+        "description": "",
+        "link": "",
+        "protocol_link": "",
+        "reso": false,
+        "present": null,
+        "notes": "",
+        "category": 5,
+        "track": null,
+        "event": 2,
+        "history_date": "2021-05-04T10:29:40.296Z",
+        "history_change_reason": null,
+        "history_type": "+",
+        "history_user": null
+    }
+},
+{
+    "model": "AKModel.historicalak",
+    "pk": 4,
+    "fields": {
+        "id": 2,
+        "name": "Test AK Meta",
+        "short_name": "test2",
+        "description": "",
+        "link": "",
+        "protocol_link": "",
+        "reso": false,
+        "present": null,
+        "notes": "",
+        "category": 5,
+        "track": null,
+        "event": 2,
+        "history_date": "2021-05-04T10:29:40.355Z",
+        "history_change_reason": null,
+        "history_type": "~",
+        "history_user": null
+    }
+},
+{
+    "model": "AKModel.historicalak",
+    "pk": 5,
+    "fields": {
+        "id": 3,
+        "name": "AK Wish",
+        "short_name": "wish1",
+        "description": "Description of my Wish",
+        "link": "",
+        "protocol_link": "",
+        "reso": false,
+        "present": null,
+        "notes": "We need to find a volunteer first...",
+        "category": 3,
+        "track": null,
+        "event": 2,
+        "history_date": "2021-05-04T10:30:59.469Z",
+        "history_change_reason": null,
+        "history_type": "+",
+        "history_user": null
+    }
+},
+{
+    "model": "AKModel.historicalak",
+    "pk": 6,
+    "fields": {
+        "id": 3,
+        "name": "AK Wish",
+        "short_name": "wish1",
+        "description": "Description of my Wish",
+        "link": "",
+        "protocol_link": "",
+        "reso": false,
+        "present": null,
+        "notes": "We need to find a volunteer first...",
+        "category": 3,
+        "track": null,
+        "event": 2,
+        "history_date": "2021-05-04T10:30:59.509Z",
+        "history_change_reason": null,
+        "history_type": "~",
+        "history_user": null
+    }
+},
+{
+    "model": "AKModel.historicalak",
+    "pk": 7,
+    "fields": {
+        "id": 2,
+        "name": "Test AK Meta",
+        "short_name": "test2",
+        "description": "",
+        "link": "",
+        "protocol_link": "",
+        "reso": false,
+        "present": null,
+        "notes": "",
+        "category": 5,
+        "track": 1,
+        "event": 2,
+        "history_date": "2022-12-02T12:27:14.277Z",
+        "history_change_reason": null,
+        "history_type": "~",
+        "history_user": null
+    }
+},
+{
+    "model": "AKModel.ak",
+    "pk": 1,
+    "fields": {
+        "name": "Test AK Inhalt",
+        "short_name": "test1",
+        "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": 2,
+    "fields": {
+        "name": "Test AK Meta",
+        "short_name": "test2",
+        "description": "",
+        "link": "",
+        "protocol_link": "",
+        "category": 5,
+        "track": 1,
+        "reso": false,
+        "present": null,
+        "notes": "",
+        "interest": -1,
+        "interest_counter": 0,
+        "event": 2,
+        "owners": [
+            2
+        ],
+        "requirements": [],
+        "conflicts": [],
+        "prerequisites": []
+    }
+},
+{
+    "model": "AKModel.ak",
+    "pk": 3,
+    "fields": {
+        "name": "AK Wish",
+        "short_name": "wish1",
+        "description": "Description of my Wish",
+        "link": "",
+        "protocol_link": "",
+        "category": 3,
+        "track": null,
+        "reso": false,
+        "present": null,
+        "notes": "We need to find a volunteer first...",
+        "interest": -1,
+        "interest_counter": 0,
+        "event": 2,
+        "owners": [],
+        "requirements": [
+            4
+        ],
+        "conflicts": [
+            1
+        ],
+        "prerequisites": [
+            2
+        ]
+    }
+},
+{
+    "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,
+    "fields": {
+        "name": "Testraum",
+        "location": "BBB",
+        "capacity": -1,
+        "event": 2,
+        "properties": [
+            3
+        ]
+    }
+},
+{
+    "model": "AKModel.room",
+    "pk": 2,
+    "fields": {
+        "name": "Testraum 2",
+        "location": "",
+        "capacity": 30,
+        "event": 2,
+        "properties": []
+    }
+},
+{
+    "model": "AKModel.room",
+    "pk": 3,
+    "fields": {
+        "name": "BBB Session 1",
+        "location": "",
+        "capacity": -1,
+        "event": 1,
+        "properties": [
+            2
+        ]
+    }
+},
+{
+    "model": "AKModel.akslot",
+    "pk": 1,
+    "fields": {
+        "ak": 1,
+        "room": 2,
+        "start": "2020-11-06T18:30:00Z",
+        "duration": "2.00",
+        "fixed": false,
+        "event": 2,
+        "updated": "2022-12-02T12:23:11.856Z"
+    }
+},
+{
+    "model": "AKModel.akslot",
+    "pk": 2,
+    "fields": {
+        "ak": 2,
+        "room": 1,
+        "start": "2020-11-08T12:30:00Z",
+        "duration": "2.00",
+        "fixed": false,
+        "event": 2,
+        "updated": "2022-12-02T12:23:18.279Z"
+    }
+},
+{
+    "model": "AKModel.akslot",
+    "pk": 3,
+    "fields": {
+        "ak": 3,
+        "room": null,
+        "start": null,
+        "duration": "1.50",
+        "fixed": false,
+        "event": 2,
+        "updated": "2021-05-04T10:30:59.523Z"
+    }
+},
+{
+    "model": "AKModel.akslot",
+    "pk": 4,
+    "fields": {
+        "ak": 3,
+        "room": null,
+        "start": null,
+        "duration": "3.00",
+        "fixed": false,
+        "event": 2,
+        "updated": "2021-05-04T10:30:59.528Z"
+    }
+},
+{
+    "model": "AKModel.akslot",
+    "pk": 5,
+    "fields": {
+        "ak": 1,
+        "room": null,
+        "start": null,
+        "duration": "2.00",
+        "fixed": false,
+        "event": 2,
+        "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,
+    "fields": {
+        "type": "soa",
+        "level": 10,
+        "event": 2,
+        "ak_owner": null,
+        "room": null,
+        "requirement": null,
+        "category": null,
+        "comment": "",
+        "timestamp": "2022-12-02T12:23:11.875Z",
+        "manually_resolved": false,
+        "aks": [
+            1
+        ],
+        "ak_slots": [
+            1
+        ]
+    }
+},
+{
+    "model": "AKModel.constraintviolation",
+    "pk": 2,
+    "fields": {
+        "type": "rng",
+        "level": 10,
+        "event": 2,
+        "ak_owner": null,
+        "room": 2,
+        "requirement": 3,
+        "category": null,
+        "comment": "",
+        "timestamp": "2022-12-02T12:23:11.890Z",
+        "manually_resolved": false,
+        "aks": [
+            1
+        ],
+        "ak_slots": [
+            1
+        ]
+    }
+},
+{
+    "model": "AKModel.constraintviolation",
+    "pk": 3,
+    "fields": {
+        "type": "soa",
+        "level": 10,
+        "event": 2,
+        "ak_owner": null,
+        "room": null,
+        "requirement": null,
+        "category": null,
+        "comment": "",
+        "timestamp": "2022-12-02T12:23:18.301Z",
+        "manually_resolved": false,
+        "aks": [
+            2
+        ],
+        "ak_slots": [
+            2
+        ]
+    }
+},
+{
+    "model": "AKModel.availability",
+    "pk": 1,
+    "fields": {
+        "event": 2,
+        "person": null,
+        "room": null,
+        "ak": 1,
+        "ak_category": null,
+        "start": "2020-11-07T08:00:00Z",
+        "end": "2020-11-07T18:00:00Z"
+    }
+},
+{
+    "model": "AKModel.availability",
+    "pk": 2,
+    "fields": {
+        "event": 2,
+        "person": null,
+        "room": null,
+        "ak": 1,
+        "ak_category": null,
+        "start": "2020-11-09T10:00:00Z",
+        "end": "2020-11-09T16:30:00Z"
+    }
+},
+{
+    "model": "AKModel.availability",
+    "pk": 3,
+    "fields": {
+        "event": 2,
+        "person": null,
+        "room": 1,
+        "ak": null,
+        "ak_category": null,
+        "start": "2020-11-06T17:51:26Z",
+        "end": "2020-11-10T23:00:00Z"
+    }
+},
+{
+    "model": "AKModel.availability",
+    "pk": 4,
+    "fields": {
+        "event": 2,
+        "person": null,
+        "room": 2,
+        "ak": null,
+        "ak_category": null,
+        "start": "2020-11-06T17:51:26Z",
+        "end": "2020-11-06T21:00:00Z"
+    }
+},
+{
+    "model": "AKModel.availability",
+    "pk": 5,
+    "fields": {
+        "event": 2,
+        "person": null,
+        "room": 2,
+        "ak": null,
+        "ak_category": null,
+        "start": "2020-11-08T15:30:00Z",
+        "end": "2020-11-08T19:30:00Z"
+    }
+},
+{
+    "model": "AKModel.availability",
+    "pk": 6,
+    "fields": {
+        "event": 2,
+        "person": null,
+        "room": 2,
+        "ak": null,
+        "ak_category": null,
+        "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

-from bootstrap_datepicker_plus import DateTimePickerInput
+"""
+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 ugettext_lazy as _
+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
+
 
-from AKModel.models import Event, AKCategory, AKRequirement
+class DateTimeInput(forms.DateInput):
+    """
+    Simple widget for datetime input fields using the HTML5 datetime-local input type
+    """
+    input_type = 'datetime-local'
 
 
 class NewEventWizardStartForm(forms.ModelForm):
+    """
+    Initial view of new event wizard
+
+    This form is a model form for Event, but only with a subset of the required fields.
+    It is therefore not possible to really create an event using this form, but only to enter
+    information, in particular the timezone, that is needed to correctly handle/parse the user
+    inputs for further required fields like start and end of the event.
+
+    The form will be used for this partial input, the input of the remaining required fields
+    will then be handled by :class:`NewEventWizardSettingsForm` (see below).
+    """
     class Meta:
         model = Event
-        fields = ['name', 'slug', 'timezone']
+        fields = ['name', 'slug', 'timezone', 'plan_hidden']
+        widgets = {
+            'plan_hidden': forms.HiddenInput(),
+        }
 
+    # Special hidden field for wizard state handling
     is_init = forms.BooleanField(initial=True, widget=forms.HiddenInput)
 
 
 class NewEventWizardSettingsForm(forms.ModelForm):
+    """
+    Form for second view of the event creation wizard.
+
+    Will handle the input of the remaining required as well as some optional fields.
+    See also :class:`NewEventWizardStartForm`.
+    """
     class Meta:
         model = Event
-        exclude = []
+        fields = "__all__"
+        exclude = ['plan_published_at']
         widgets = {
             'name': forms.HiddenInput(),
             'slug': forms.HiddenInput(),
             'timezone': forms.HiddenInput(),
             'active': forms.HiddenInput(),
+            'start': DateTimeInput(),
+            'end': DateTimeInput(),
+            'interest_start': DateTimeInput(),
+            'interest_end': DateTimeInput(),
+            'reso_deadline': DateTimeInput(),
             'plan_hidden': forms.HiddenInput(),
-            'start': DateTimePickerInput(options={"format": "YYYY-MM-DD HH:mm"}),
-            'end': DateTimePickerInput(options={"format": "YYYY-MM-DD HH:mm"}),
-            'reso_deadline': DateTimePickerInput(options={"format": "YYYY-MM-DD HH:mm"}),
         }
 
 
 class NewEventWizardPrepareImportForm(forms.Form):
+    """
+    Wizard form for choosing an event to import/copy elements (requirements, categories, etc) from.
+    Is used to restrict the list of elements to choose from in the next step (see :class:`NewEventWizardImportForm`).
+    """
     import_event = forms.ModelChoiceField(
         queryset=Event.objects.all(),
         label=_("Copy ak requirements and ak categories of existing event"),
@@ -39,6 +85,12 @@ class NewEventWizardPrepareImportForm(forms.Form):
 
 
 class NewEventWizardImportForm(forms.Form):
+    """
+    Wizard form for excaclty choosing which elemments to copy/import for the newly created event.
+    Possible elements are categories, requirements, and dashboard buttons if AKDashboard is active.
+    The lists are restricted to elements from the event selected in the previous step
+    (see :class:`NewEventWizardPrepareImportForm`).
+    """
     import_categories = forms.ModelMultipleChoiceField(
         queryset=AKCategory.objects.all(),
         widget=forms.CheckboxSelectMultiple,
@@ -53,16 +105,268 @@ class NewEventWizardImportForm(forms.Form):
         required=False,
     )
 
+    import_types = forms.ModelMultipleChoiceField(
+        queryset=AKType.objects.all(),
+        widget=forms.CheckboxSelectMultiple,
+        label=_("Copy types"),
+        required=False,
+    )
+
+    # pylint: disable=too-many-arguments
     def __init__(self, data=None, files=None, auto_id='id_%s', prefix=None, initial=None, error_class=ErrorList,
                  label_suffix=None, empty_permitted=False, field_order=None, use_required_attribute=None,
                  renderer=None):
         super().__init__(data, files, auto_id, prefix, initial, error_class, label_suffix, empty_permitted, field_order,
                          use_required_attribute, renderer)
-        self.fields["import_categories"].queryset = self.fields["import_categories"].queryset.filter(event=self.initial["import_event"])
-        self.fields["import_requirements"].queryset = self.fields["import_requirements"].queryset.filter(event=self.initial["import_event"])
+        self.fields["import_categories"].queryset = self.fields["import_categories"].queryset.filter(
+            event=self.initial["import_event"])
+        self.fields["import_requirements"].queryset = self.fields["import_requirements"].queryset.filter(
+            event=self.initial["import_event"])
+        self.fields["import_types"].queryset = self.fields["import_types"].queryset.filter(
+            event=self.initial["import_event"])
+
+        # pylint: disable=import-outside-toplevel
+        # Local imports used to prevent cyclic imports and to only import when AKDashboard is available
+        from django.apps import apps
+        if apps.is_installed("AKDashboard"):
+            # If AKDashboard is active, allow to copy dashboard buttons, too
+            from AKDashboard.models import DashboardButton
+            self.fields["import_buttons"] = forms.ModelMultipleChoiceField(
+                queryset=DashboardButton.objects.filter(event=self.initial["import_event"]),
+                widget=forms.CheckboxSelectMultiple,
+                label=_("Copy dashboard buttons"),
+                required=False,
+            )
 
 
 class NewEventWizardActivateForm(forms.ModelForm):
+    """
+    Wizard form to activate the newly created event
+    """
     class Meta:
         fields = ["active"]
         model = Event
+
+
+class AdminIntermediateForm(forms.Form):
+    """
+    Base form for admin intermediate views (forms used there should inherit from this,
+    by default, the form is empty since it is only needed for the confirmation button)
+    """
+
+
+class AdminIntermediateActionForm(AdminIntermediateForm):
+    """
+    Form for Admin Action Confirmation views -- has a pks field needed to handle the serialization/deserialization of
+    the IDs of the entities the user selected for the admin action to be performed on
+    """
+    pks = forms.CharField(widget=forms.HiddenInput)
+
+
+class SlideExportForm(AdminIntermediateForm):
+    """
+    Form to control the slides generated from the AK list of an event
+
+    The user can select how many upcoming AKs are displayed at the footer to inform people that it is their turn soon,
+    whether the AK list should be restricted to those AKs that where marked for presentation, and whether ther should
+    be a symbol and empty space to take notes on for wishes
+    """
+    num_next = forms.IntegerField(
+        min_value=0,
+        max_value=6,
+        initial=3,
+        label=_("# next AKs"),
+        help_text=_("How many next AKs should be shown on a slide?"))
+    presentation_mode = forms.TypedChoiceField(
+        initial=False,
+        label=_("Presentation only?"),
+        widget=forms.RadioSelect,
+        choices=((True, _('Yes')), (False, _('No'))),
+        coerce=lambda x: x == "True",
+        help_text=_("Restrict AKs to those that asked for chance to be presented?"))
+    wish_notes = forms.TypedChoiceField(
+        initial=False,
+        label=_("Space for notes in wishes?"),
+        widget=forms.RadioSelect,
+        choices=((True, _('Yes')), (False, _('No'))),
+        coerce=lambda x: x == "True",
+        help_text=_("Create symbols indicating space to note down owners and timeslots for wishes, e.g., to be filled "
+                    "out on a touch screen while presenting?"))
+
+
+class DefaultSlotEditorForm(AdminIntermediateForm):
+    """
+    Form for default slot editor
+    """
+    availabilities = forms.CharField(
+        label=_('Default Slots'),
+        help_text=_(
+            'Click and drag to add default slots, double-click to delete. '
+            'Or use the start and end inputs to add entries to the calendar view.'
+        ),
+        widget=forms.TextInput(attrs={'class': 'availabilities-editor-data'}),
+        required=True,
+    )
+
+
+class RoomBatchCreationForm(AdminIntermediateForm):
+    """
+    Form for room batch creation
+
+    Allows to input a list of room details and choose whether default availabilities should be generated for these
+    rooms. Will check that the input follows a CSV format with at least a name column present.
+    """
+    rooms = forms.CharField(
+        label=_('New rooms'),
+        help_text=_('Enter room details in CSV format. Required colum is "name", optional colums are "location", '
+                    '"capacity", and "url" for online/hybrid rooms. Delimiter: Semicolon'),
+        widget=forms.Textarea,
+        required=True,
+    )
+    create_default_availabilities = forms.BooleanField(
+        label=_('Default availabilities?'),
+        help_text=_('Create default availabilities for all rooms?'),
+        required=False
+    )
+
+    def clean_rooms(self):
+        """
+        Validate and transform the input for the rooms textfield
+        Treat the input as CSV and turn it into a dict containing the relevant information.
+
+        :return: a dict containing the raw room information
+        :rtype: dict[str, str]
+        """
+        rooms_raw_text = self.cleaned_data["rooms"]
+        rooms_raw_dict = csv.DictReader(io.StringIO(rooms_raw_text), delimiter=";")
+
+        if "name" not in rooms_raw_dict.fieldnames:
+            raise forms.ValidationError(_("CSV must contain a name column"))
+
+        return rooms_raw_dict
+
+
+class RoomForm(forms.ModelForm):
+    """
+    Room (creation) form (basic), will be extended for handling of availabilities
+    (see :class:`RoomFormWithAvailabilities`) and also for creating hybrid rooms in AKOnline (if active)
+    """
+    class Meta:
+        model = Room
+        fields = ['name',
+                  'location',
+                  'capacity',
+                  'event',
+                  ]
+
+
+class RoomFormWithAvailabilities(AvailabilitiesFormMixin, RoomForm):
+    """
+    Room (update) form including handling of availabilities, extends :class:`RoomForm`
+    """
+    class Meta:
+        model = Room
+        fields = ['name',
+                  'location',
+                  'capacity',
+                  'properties',
+                  'event',
+                  ]
+
+        widgets = {
+            'properties': forms.CheckboxSelectMultiple,
+        }
+
+    def __init__(self, *args, **kwargs):
+        # Init availability mixin
+        kwargs['initial'] = {}
+        super().__init__(*args, **kwargs)
+        self.initial = {**self.initial, **kwargs['initial']}
+        # 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/metaviews/__init__.py

+from AKModel.metaviews.status import StatusManager
+
+# create on instance of the :class:`AKModel.metaviews.status.StatusManager`
+# that can then be accessed everywhere (singleton pattern)
+status_manager = StatusManager()

AKModel/migrations/0058_alter_ak_options.py

+# Generated by Django 4.1.9 on 2023-05-15 18:47
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('AKModel', '0057_upgrades'),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name='ak',
+            options={'ordering': ['pk'], 'verbose_name': 'AK', 'verbose_name_plural': 'AKs'},
+        ),
+    ]