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.forms import JSONExportControlForm
+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})
+
+        form = JSONExportControlForm(event=event)
+
+        # TODO: test with values other than default
+        data = {
+            field_name: list(map(str, field.prepare_value(field.initial)))
+            for field_name, field in form.fields.items()
+            if field.initial is not None
+        }
+
+        response = self.client.post(export_url, data=data)
+
+        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.db.models import Q
+from django.db.models.query import QuerySet
+from django.shortcuts import redirect
+from django.utils.translation import gettext_lazy as _
+from django.views.generic import FormView
+
+from AKModel.metaviews.admin import (
+    AdminViewMixin,
+    EventSlugMixin,
+    IntermediateAdminView,
+)
+from AKModel.models import AK, Event
+from AKSolverInterface.forms import JSONExportControlForm, JSONScheduleImportForm
+from AKSolverInterface.serializers import ExportEventSerializer
+
+
+class AKJSONExportView(EventSlugMixin, AdminViewMixin, FormView):
+    """
+    View: Export all AK slots of this event in JSON format ordered by tracks
+    """
+
+    template_name = "admin/AKSolverInterface/ak_json_export.html"
+    model = Event
+    form_class = JSONExportControlForm
+    title = _("AK JSON Export")
+
+    def get_template_names(self):
+        if self.request.method == "POST":
+            return ["admin/AKSolverInterface/ak_json_export.html"]
+        return ["admin/AKSolverInterface/ak_json_export_control.html"]
+
+    def get_form_kwargs(self):
+        form_kwargs = super().get_form_kwargs()
+        form_kwargs["event"] = self.event
+        return form_kwargs
+
+    def form_valid(self, form):
+        context = self.get_context_data()
+        try:
+            aks_without_slot = AK.objects.filter(event=self.event, akslot__isnull=True).all()
+            if aks_without_slot.exists():
+                messages.warning(
+                    self.request,
+                    _(
+                        "The following AKs have no slot assigned to them "
+                        "and are therefore not exported: {aks_list}"
+                    ).format(
+                        aks_list=", ".join(aks_without_slot.values_list("name", flat=True))
+                    )
+                )
+
+            def _filter_slots_cb(queryset: QuerySet) -> QuerySet:
+                queryset = queryset.prefetch_related("ak")
+                if "export_tracks" in form.cleaned_data:
+                    queryset = queryset.filter(
+                        Q(ak__track__in=form.cleaned_data["export_tracks"])
+                        | Q(ak__track__isnull=True)
+                    )
+                if "export_categories" in form.cleaned_data:
+                    queryset = queryset.filter(
+                        Q(ak__category__in=form.cleaned_data["export_categories"])
+                        | Q(ak__category__isnull=True)
+                    )
+                if "export_types" in form.cleaned_data:
+                    queryset = queryset.filter(
+                        Q(ak__types__in=form.cleaned_data["export_types"])
+                        | Q(ak__types__isnull=True)
+                    )
+
+                queryset = queryset.distinct().all()
+                if not queryset.exists():
+                    messages.warning(
+                        self.request,
+                        _("No AKSlots are exported"),
+                    )
+
+                return queryset
+
+            def _filter_rooms_cb(queryset: QuerySet) -> QuerySet:
+                queryset = queryset.all()
+                if not queryset.exists():
+                    messages.warning(self.request, _("No Rooms are exported"))
+                return queryset
+
+            def _filter_participants_cb(queryset: QuerySet) -> QuerySet:
+                queryset = queryset.all()
+                if not queryset.exists():
+                    messages.warning(self.request, _("No real participants are exported"))
+                return queryset
+
+            serialized_event = ExportEventSerializer(
+                context["event"],
+                filter_slots_cb=_filter_slots_cb,
+                filter_rooms_cb=_filter_rooms_cb,
+                filter_participants_cb=_filter_participants_cb,
+                export_scheduled_aks_as_fixed=form.cleaned_data["export_scheduled_aks_as_fixed"],
+            )
+            serialized_event_data = serialized_event.data
+
+            if not serialized_event_data["timeslots"]["blocks"]:
+                messages.warning(self.request, _("No timeslots are exported"))
+            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),
+            )
+
+        # 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"],
+                check_for_data_inconsistency=False, # TODO: Actually handle filtered export
+            )
+            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/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,8 +18,8 @@ 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'])
@@ -26,7 +27,7 @@ def increment_interest_counter(request, event_slug, pk, **kwargs):
     """
     Increment interest counter for AK
 
-    This view either returns a HTTP 200 if the counter was incremented,
+    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.
     """

AKSubmission/forms.py

@@ -11,7 +11,7 @@ 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
+from AKModel.models import AK, AKCategory, AKOrgaMessage, AKOwner, AKRequirement, AKSlot, AKType
 
 
 class AKForm(AvailabilitiesFormMixin, forms.ModelForm):
@@ -33,11 +33,13 @@ class AKForm(AvailabilitiesFormMixin, forms.ModelForm):
         model = AK
         fields = ['name',
                   'short_name',
-                  'link',
                   'protocol_link',
                   'owners',
                   'description',
+                  'goal',
+                  'info',
                   'category',
+                  'types',
                   'reso',
                   'present',
                   'requirements',
@@ -49,6 +51,7 @@ class AKForm(AvailabilitiesFormMixin, forms.ModelForm):
 
         widgets = {
             'requirements': forms.CheckboxSelectMultiple,
+            'types': forms.CheckboxSelectMultiple,
             'event': forms.HiddenInput,
         }
 
@@ -62,7 +65,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(
@@ -87,7 +97,7 @@ class AKForm(AvailabilitiesFormMixin, forms.ModelForm):
             duration = float(duration.replace(",", "."))
 
         try:
-            float(duration)
+            duration = float(duration)
         except ValueError as exc:
             raise ValidationError(
                 _('"%(duration)s" is not a valid duration'),
@@ -101,7 +111,7 @@ class AKForm(AvailabilitiesFormMixin, forms.ModelForm):
         """
         Normalize/clean inputs
 
-        Generate a (not yet used) short name if field was left blank, generate a wiki link,
+        Generate a (not yet used) short name if field was left blank,
         create a list of normalized slot durations
 
         :return: cleaned inputs
@@ -128,12 +138,6 @@ class AKForm(AvailabilitiesFormMixin, forms.ModelForm):
                 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()]
@@ -150,6 +154,9 @@ class AKSubmissionForm(AKForm):
     class Meta(AKForm.Meta):
         # 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)
@@ -186,6 +193,9 @@ class AKWishForm(AKForm):
     class Meta(AKForm.Meta):
         # 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):

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-08-16 16:30+0200\n"
+"POT-Creation-Date: 2025-06-24 11:10+0000\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:93
+#: AKSubmission/forms.py:103
 #, python-format
 msgid "\"%(duration)s\" is not a valid duration"
 msgstr "\"%(duration)s\" ist keine gültige Dauer"
 
-#: AKSubmission/forms.py:159
+#: AKSubmission/forms.py:166
 msgid "Duration(s)"
 msgstr "Dauer(n)"
 
-#: AKSubmission/forms.py:161
+#: AKSubmission/forms.py:168
 msgid ""
 "Enter at least one planned duration (in hours). If your AK should have "
 "multiple slots, use multiple lines"
@@ -46,178 +46,191 @@ msgstr ""
 #: AKSubmission/templates/AKSubmission/submission_not_configured.html:11
 #: 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/submission_overview.html:40
+#: AKSubmission/templates/AKSubmission/submit_new.html:39
 #: 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:125
 #: 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:127
 #: 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:148
 msgid "Interest"
 msgstr "Interesse"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:102
-#: AKSubmission/templates/AKSubmission/ak_table.html:55
+#: AKSubmission/templates/AKSubmission/ak_detail.html:150
+#: 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:156
+#: 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:161
 msgid "Open protocol link"
 msgstr "Protokolllink öffnen"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:118
+#: AKSubmission/templates/AKSubmission/ak_detail.html:166
 #: 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:169
 #: 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:172
+#: AKSubmission/templates/AKSubmission/ak_detail.html:334
 #: 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:177
 #: 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:190
 #, 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:195
+#: AKSubmission/templates/AKSubmission/ak_detail.html:342
 msgid "Go to virtual room"
 msgstr "Zum virtuellen Raum"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:158
+#: AKSubmission/templates/AKSubmission/ak_detail.html:206
 #: AKSubmission/templates/AKSubmission/ak_table.html:10
 msgid "Who?"
 msgstr "Wer?"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:164
+#: AKSubmission/templates/AKSubmission/ak_detail.html:212
 #: 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:219
+#: AKSubmission/templates/AKSubmission/ak_list.html:24
+#: AKSubmission/templates/AKSubmission/ak_table.html:13
+msgid "Types"
+msgstr "Typen"
+
+#: AKSubmission/templates/AKSubmission/ak_detail.html:229
 #: 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:235
 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:241
 msgid "(Category Default)"
 msgstr "(Kategorievoreinstellung)"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:188
+#: AKSubmission/templates/AKSubmission/ak_detail.html:247
 msgid "Reso intention?"
 msgstr "Resoabsicht?"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:195
+#: AKSubmission/templates/AKSubmission/ak_detail.html:254
 msgid "Requirements"
 msgstr "Anforderungen"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:208
+#: AKSubmission/templates/AKSubmission/ak_detail.html:267
 msgid "Conflicting AKs"
 msgstr "AK-Konflikte"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:216
+#: AKSubmission/templates/AKSubmission/ak_detail.html:275
 msgid "Prerequisite AKs"
 msgstr "Vorausgesetzte AKs"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:224
+#: AKSubmission/templates/AKSubmission/ak_detail.html:283
 msgid "Notes"
 msgstr "Notizen"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:237
+#: AKSubmission/templates/AKSubmission/ak_detail.html:290
+msgid "Brief Description:"
+msgstr "Kurzbeschreibung:"
+
+#: AKSubmission/templates/AKSubmission/ak_detail.html:291
+msgid "Design/Goal:"
+msgstr "Art/Ziel:"
+
+#: AKSubmission/templates/AKSubmission/ak_detail.html:293
+msgid "Further Info:"
+msgstr "Weitere Infos:"
+
+#: AKSubmission/templates/AKSubmission/ak_detail.html:302
 msgid "When?"
 msgstr "Wann?"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:239
+#: AKSubmission/templates/AKSubmission/ak_detail.html:304
 #: AKSubmission/templates/AKSubmission/akslot_delete.html:35
 msgid "Duration"
 msgstr "Dauer"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:241
+#: AKSubmission/templates/AKSubmission/ak_detail.html:306
 msgid "Room"
 msgstr "Raum"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:272
+#: AKSubmission/templates/AKSubmission/ak_detail.html:337
 msgid "Delete"
 msgstr "Löschen"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:283
+#: AKSubmission/templates/AKSubmission/ak_detail.html:348
 msgid "Schedule"
 msgstr "Schedule"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:295
+#: AKSubmission/templates/AKSubmission/ak_detail.html:360
 msgid "Add another slot"
 msgstr "Einen neuen AK-Slot hinzufügen"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:305
+#: AKSubmission/templates/AKSubmission/ak_detail.html:370
 msgid "Possible Times"
 msgstr "Mögliche Zeiten"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:309
+#: AKSubmission/templates/AKSubmission/ak_detail.html:374
 msgid "Start"
 msgstr "Start"
 
-#: AKSubmission/templates/AKSubmission/ak_detail.html:310
+#: AKSubmission/templates/AKSubmission/ak_detail.html:375
 msgid "End"
 msgstr "Ende"
 
@@ -232,7 +245,7 @@ msgstr "Ende"
 #: AKSubmission/templates/AKSubmission/akslot_delete.html:7
 #: AKSubmission/templates/AKSubmission/submission_not_configured.html:7
 #: AKSubmission/templates/AKSubmission/submission_overview.html:7
-#: AKSubmission/templates/AKSubmission/submission_overview.html:40
+#: AKSubmission/templates/AKSubmission/submission_overview.html:44
 #: AKSubmission/templates/AKSubmission/submit_new.html:9
 #: AKSubmission/templates/AKSubmission/submit_new_wish.html:7
 msgid "AKs"
@@ -269,16 +282,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:84
+#: AKSubmission/templates/AKSubmission/ak_list.html:6 AKSubmission/views.py:82
 msgid "All AKs"
 msgstr "Alle AKs"
 
@@ -294,11 +307,12 @@ msgstr "AK-Liste"
 msgid "Add AK"
 msgstr "AK hinzufügen"
 
-#: AKSubmission/templates/AKSubmission/ak_table.html:42
+#: AKSubmission/templates/AKSubmission/ak_table.html:52
+#: AKSubmission/templates/AKSubmission/ak_table.html:77
 msgid "Details"
 msgstr "Details"
 
-#: AKSubmission/templates/AKSubmission/ak_table.html:66
+#: AKSubmission/templates/AKSubmission/ak_table.html:88
 msgid "There are no AKs in this category yet"
 msgstr "Es gibt noch keine AKs in dieser Kategorie"
 
@@ -309,7 +323,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:63
 msgid "Reset Form"
 msgstr "Formular leeren"
 
@@ -317,7 +331,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:67
 msgid "Cancel"
 msgstr "Abbrechen"
 
@@ -361,54 +375,91 @@ msgstr ""
 "Das System ist bisher nicht für Eintragen und Anzeige von AKs konfiguriert. "
 "Bitte versuche es später wieder."
 
-#: AKSubmission/templates/AKSubmission/submission_overview.html:44
+#: AKSubmission/templates/AKSubmission/submission_overview.html:48
 msgid ""
 "On this page you can see a list of current AKs, change them and add new ones."
 msgstr ""
 "Auf dieser Seite kannst du eine Liste von aktuellen AKs sehen, diese "
 "bearbeiten und neue hinzufügen."
 
-#: AKSubmission/templates/AKSubmission/submission_overview.html:52
+#: AKSubmission/templates/AKSubmission/submission_overview.html:56
 #: AKSubmission/templates/AKSubmission/submit_new_wish.html:7
 #: AKSubmission/templates/AKSubmission/submit_new_wish.html:14
 #: AKSubmission/templates/AKSubmission/submit_new_wish.html:18
 msgid "New AK Wish"
 msgstr "Neuer AK-Wunsch"
 
-#: AKSubmission/templates/AKSubmission/submission_overview.html:56
+#: AKSubmission/templates/AKSubmission/submission_overview.html:60
 msgid "Who"
 msgstr "Wer"
 
-#: AKSubmission/templates/AKSubmission/submission_overview.html:59
+#: AKSubmission/templates/AKSubmission/submission_overview.html:63
 msgid "I do not own AKs yet"
 msgstr "Ich leite bisher keine AKs"
 
-#: AKSubmission/templates/AKSubmission/submission_overview.html:67
+#: AKSubmission/templates/AKSubmission/submission_overview.html:71
 #: 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:42
+#: AKSubmission/templates/AKSubmission/submit_new.html:49
 msgid "New AK"
 msgstr "Neuer AK"
 
-#: AKSubmission/templates/AKSubmission/submission_overview.html:73
+#: AKSubmission/templates/AKSubmission/submission_overview.html:77
 msgid "Edit Person Info"
 msgstr "Personen-Info bearbeiten"
 
-#: AKSubmission/templates/AKSubmission/submission_overview.html:81
+#: AKSubmission/templates/AKSubmission/submission_overview.html:85
 msgid "This event is not active. You cannot add or change AKs"
 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:30
+msgid ""
+"This is used for presentation slides among other things, and will be "
+"truncated to 200 characters for that purpose."
+msgstr ""
+"Dieses Feld wird unter anderen für Präsentationsfolien verwendet und zu "
+"diesem Zweck auf 200 Zeichen limitiert."
+
+#: AKSubmission/templates/AKSubmission/submit_new.html:59
 msgid "Submit"
 msgstr "Eintragen"
 
-#: AKSubmission/views.py:127
+#: AKSubmission/templates/AKSubmission/submit_new.html:77
+msgid "Continue with that name?"
+msgstr "Mit dem Namen fortfahren?"
+
+#: AKSubmission/templates/AKSubmission/submit_new.html:81
+
+msgid ""
+"Your AK name (or short name) starts with or contains the word \"AK\"."
+"<br><br>This is not recommended, as it makes the names longer, and may "
+"create an inconsistent style. The tool will ensure that one always know that "
+"a title belongs to an AK even without that prefix.<br><br>Do you still want "
+"to use that name?"
+msgstr ""
+" Der Name (oder Kurzname) des AKs beginnt mit dem Wort "
+"\"AK\" oder enthält es.<br><br>"
+"Das ist nicht empfohlen, weil es den Namen länger macht "
+"und zu einem inkonsistenten Stil führen kann."
+"Das AK-Tool wird dafür sorgen, dass man immer weiß, dass "
+"der Titel zu einem AK gehört, auch ohne diesen Prefix.<br><br>"
+"Möchtest du den Namen trotzdem verwenden?"
+
+#: AKSubmission/templates/AKSubmission/submit_new.html:85
+msgid "Change name"
+msgstr "Namen ändern"
+
+#: AKSubmission/templates/AKSubmission/submit_new.html:87
+msgid "Proceed with saving"
+msgstr "Mit dem Speichern fortfahren"
+
+#: AKSubmission/views.py:125
 msgid "Wishes"
 msgstr "Wünsche"
 
-#: AKSubmission/views.py:127
+#: 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 "
@@ -418,72 +469,59 @@ msgstr ""
 msgid "Currently planned AKs"
 msgstr "Aktuell geplante AKs"
 
-#: AKSubmission/views.py:300
+#: AKSubmission/views.py:337
 msgid "Event inactive. Cannot create or update."
 msgstr "Event inaktiv. Hinzufügen/Bearbeiten nicht möglich."
 
-#: AKSubmission/views.py:325
+#: AKSubmission/views.py:362
 msgid "AK successfully created"
 msgstr "AK erfolgreich angelegt"
 
-#: AKSubmission/views.py:398
+#: AKSubmission/views.py:436
 msgid "AK successfully updated"
 msgstr "AK erfolgreich aktualisiert"
 
-#: AKSubmission/views.py:449
+#: 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:553
+#: AKSubmission/views.py:590
 msgid "No user selected"
 msgstr "Keine Person ausgewählt"
 
-#: AKSubmission/views.py:569
+#: AKSubmission/views.py:606
 msgid "Person Info successfully updated"
 msgstr "Personen-Info erfolgreich aktualisiert"
 
-#: AKSubmission/views.py:605
+#: AKSubmission/views.py:642
 msgid "AK Slot successfully added"
 msgstr "AK-Slot erfolgreich angelegt"
 
-#: AKSubmission/views.py:624
+#: 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:634
+#: AKSubmission/views.py:671
 msgid "AK Slot successfully updated"
 msgstr "AK-Slot erfolgreich aktualisiert"
 
-#: AKSubmission/views.py:652
+#: 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:662
+#: AKSubmission/views.py:699
 msgid "AK Slot successfully deleted"
 msgstr "AK-Slot erfolgreich angelegt"
 
-#: AKSubmission/views.py:674
+#: AKSubmission/views.py:711
 msgid "Messages"
 msgstr "Nachrichten"
 
-#: AKSubmission/views.py:684
+#: AKSubmission/views.py:721
 msgid "Delete all messages"
 msgstr "Alle Nachrichten löschen"
 
-#: AKSubmission/views.py:711
+#: AKSubmission/views.py:748
 msgid "Message to organizers successfully saved"
 msgstr "Nachricht an die Organisator*innen erfolgreich gespeichert"
-
-#~ msgid ""
-#~ "Due to technical reasons, the link you entered was truncated to a length "
-#~ "of 200 characters"
-#~ msgstr ""
-#~ "Aus technischen Gründen wurde der eingegebeneLink auf eine Länge von 200 "
-#~ "Zeichen gekürzt"
-
-#~ msgid "Interest saved"
-#~ msgstr "Interesse gespeichert"
-
-#~ msgid "Present AK results"
-#~ msgstr "AK-Ergebnisse vorstellen"

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
@@ -65,8 +114,7 @@
                     $.ajax({
                         url: "{% url "model:AK-list" event_slug=event.slug %}" + ak_id + "/indicate-interest/",
                         type: 'POST',
-                            data: {
-                            },
+                        data: {},
                         success: function (response) {
                             btn.html('{% fa6_icon 'check' 'fas' %}');
                             btn.off('click');
@@ -128,21 +176,23 @@
 
     <h2>{% if ak.wish %}{% trans "AK Wish" %}: {% endif %}{{ ak.name }}</h2>
 
+    <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">
+            <div class="card border-success mt-3 mb-3" v-show="showFeatured">
                 <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 %}
+                    <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 }}">
@@ -152,6 +202,8 @@
                 </div>
             </div>
         {% endif %}
+    </div>
+
 
     <table class="table table-borderless">
         <tr>
@@ -166,6 +218,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>
@@ -179,7 +241,8 @@
                     {% if ak.present != None %}
                         {{ ak.present | bool_symbol }}
                     {% else %}
-                        {{ ak.category.present_by_default | bool_symbol }} <span class="text-muted">{% trans "(Category Default)" %}</span>
+                        {{ ak.category.present_by_default | bool_symbol }}
+                        <span class="text-muted">{% trans "(Category Default)" %}</span>
                     {% endif %}
                 </td>
             </tr>
@@ -227,7 +290,13 @@
         {% endif %}
     </table>
 
-    <p style="margin-top: 30px;margin-bottom: 30px;">{{ ak.description|linebreaks }}</p>
+    <div class="mt-4 mb-4">
+        <p><strong>{% trans "Brief Description:" %}</strong>{{ ak.description|linebreaks }}</p>
+        <p><strong>{% trans "Design/Goal:" %}</strong>{{ ak.goal|linebreaks }}</p>
+        {% if ak.info %}
+            <p><strong>{% trans "Further Info:" %}</strong>{{ ak.info|linebreaks }}</p>
+        {% endif %}
+    </div>
 
     {% if not ak.wish %}
         <table class="table">

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' %}"
@@ -53,13 +63,25 @@
                     {% if interest_indication_active %}
                         <span data-ak_id="{{ ak.pk }}" data-bs-toggle="tooltip"
                               title="{% trans 'Show Interest' %}"
-                           class="btn btn-primary btn-interest" style="cursor: pointer">{% fa6_icon 'thumbs-up' 'fas' %}</span>
+                              class="btn btn-primary btn-interest"
+                              style="cursor: pointer">{% fa6_icon 'thumbs-up' 'fas' %}</span>
                     {% endif %}
                 {% endif %}
             </td>
         </tr>
         <tr>
-            <td colspan="5" class="small">{{ ak.description|linebreaks }}</td>
+        <tr>
+            <td colspan="5" class="small">
+                <div class="d-block d-md-none">
+                    <details>
+                        <summary>{% trans "Details" %}</summary>
+                        {{ ak.description|linebreaks }}
+                    </details>
+                </div>
+                <div class="d-none d-md-block">
+                    {{ ak.description|linebreaks }}
+                </div>
+            </td>
         </tr>
     {% empty %}
         <tr>

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" %}

AKSubmission/templates/AKSubmission/submit_new.html

@@ -23,6 +23,14 @@
             );
         });
     </script>
+
+
+    <style>
+        #id_description_helptext::after {
+            content: " ({% trans "This is used for presentation slides among other things, and will be truncated to 200 characters for that purpose." %})";
+            color: #6c757d;
+        }
+    </style>
 {% endblock %}
 
 {% block breadcrumbs %}
@@ -40,9 +48,12 @@
     {% block headline %}
         <h2>{% trans 'New AK' %}</h2>
     {% endblock %}
-    <form method="POST" class="post-form">{% csrf_token %}
+    <div id="app">
+        <form method="POST" class="post-form" id="formAK" @submit.prevent="handleSubmit">{% csrf_token %}
             {% block form_contents %}
-            {% bootstrap_form form %}
+                {#  Generate form, but make sure availabilities are always at the bottom #}
+                {% bootstrap_form form exclude='availabilities' %}
+                {% bootstrap_field form.availabilities form_group_class="" %}
             {% endblock %}
             <button type="submit" class="save btn btn-primary float-end">
                 {% fa6_icon "check" 'fas' %} {% trans "Submit" %}
@@ -56,6 +67,32 @@
                 {% fa6_icon "times" 'fas' %} {% trans "Cancel" %}
             </a>
         </form>
+
+        {# Modal for confirmation #}
+        <div class="modal fade" id="akWarningModal" tabindex="-1" aria-labelledby="akWarningModalLabel"
+             aria-hidden="true">
+            <div class="modal-dialog">
+                <div class="modal-content">
+                    <div class="modal-header">
+                        <h5 class="modal-title" id="akWarningModalLabel">{% trans "Continue with that name?" %}</h5>
+                        <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Schließen"></button>
+                    </div>
+                    <div class="modal-body">
+                        {% blocktrans %}Your AK name (or short name) starts with or contains the word "AK".<br><br>This
+                            is not recommended, as it makes the names longer, and may create an inconsistent style. The
+                            tool will ensure that one always know that a title belongs to an AK even without that
+                            prefix.<br><br>Do you still want to use that name?{% endblocktrans %}
+                    </div>
+                    <div class="modal-footer">
+                        <button type="button" class="btn btn-primary"
+                                data-bs-dismiss="modal">{% trans "Change name" %}</button>
+                        <button type="button" class="btn btn-warning"
+                                @click="proceedSubmit">{% trans "Proceed with saving" %}</button>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
 {% endblock %}
 
 {% block bottom_script %}

AKSubmission/templates/AKSubmission/type_linked_badge.html

+<a href="{% url 'submit:ak_list_by_type' event_slug=event_slug type_slug=type.slug %}">
+    <span class="badge bg-info">{{ type }}</span>
+</a>

AKSubmission/templatetags/tags_AKSubmission.py

@@ -49,3 +49,14 @@ def category_linked_badge(category, event_slug):
     :return: html fragment containing badge
     """
     return {"category": category, "event_slug": event_slug}
+
+
+@register.inclusion_tag("AKSubmission/type_linked_badge.html")
+def type_linked_badge(ak_type, event_slug):
+    """
+    Generate a clickable type badge based upon the type_linked_badge template
+    :param ak_type: type to show/link
+    :param event_slug: slug of this event, required for link creation
+    :return: html fragment containing badge
+    """
+    return {"type": ak_type, "event_slug": event_slug}

AKSubmission/tests.py

-from datetime import timedelta
+from datetime import datetime, timedelta
 
 from django.test import TestCase
 from django.urls import reverse_lazy
-from django.utils.datetime_safe import datetime
 
 from AKModel.models import AK, AKSlot, Event
-from AKModel.tests import BasicViewTests
+from AKModel.tests.test_views import BasicViewTests
+from AKSubmission.forms import AKSubmissionForm
 
 
 class ModelViewTests(BasicViewTests, TestCase):
@@ -146,7 +146,8 @@ class ModelViewTests(BasicViewTests, TestCase):
         add_redirect_url = reverse_lazy(f"{self.APP_NAME}:submit_ak", kwargs={'event_slug': 'kif42', 'owner_slug': 'a'})
         response = self.client.post(select_url, {'owner_id': 1})
         self.assertRedirects(response, add_redirect_url, status_code=302, target_status_code=200,
-                    msg_prefix=f"Dispatch redirect to ak submission page failed (should go to {add_redirect_url})")
+                             msg_prefix=f"Dispatch redirect to ak submission page failed "
+                                        f"(should go to {add_redirect_url})")
 
     def test_orga_message_submission(self):
         """
@@ -200,7 +201,8 @@ class ModelViewTests(BasicViewTests, TestCase):
         # Test indication outside of indication window -> HTTP 403, counter not increased
         response = self.client.post(interest_api_url)
         self.assertEqual(response.status_code, 403,
-                    "API end point still reachable even though interest indication window ended ({interest_api_url})")
+                         "API end point still reachable even though interest indication window ended "
+                         "({interest_api_url})")
         self.assertEqual(AK.objects.get(pk=1).interest_counter, ak_interest_counter + 1,
                          "Counter was increased even though interest indication window ended")
 
@@ -236,3 +238,39 @@ class ModelViewTests(BasicViewTests, TestCase):
                              msg_prefix=f"No correct redirect: {add_new_user_to_ak_url} (POST) -> {detail_url}")
         self._assert_message(response, "Added 'New test owner' as new owner of 'Test AK Inhalt'")
         self.assertEqual(AK.objects.get(pk=1).owners.count(), 2)
+
+    def test_visibility_requirements_in_submission_form(self):
+        """
+        Test visibility of requirements field in submission form
+        """
+        event = Event.get_by_slug('kif42')
+        form = AKSubmissionForm(data={'name': 'Test AK', 'event': event}, instance=None, initial={"event": event})
+        self.assertIn('requirements', form.fields,
+                      msg="Requirements field not present in form even though event has requirements")
+
+        event2 = Event.objects.create(name='Event without requirements',
+                                      slug='no_req',
+                                      start=datetime.now().astimezone(event.timezone),
+                                      end=datetime.now().astimezone(event.timezone),
+                                      active=True)
+        form2 = AKSubmissionForm(data={'name': 'Test AK', 'event': event2}, instance=None, initial={"event": event2})
+        self.assertNotIn('requirements', form2.fields,
+                         msg="Requirements field should not be present for events without requirements")
+
+    def test_visibility_types_in_submission_form(self):
+        """
+        Test visibility of types field in submission form
+        """
+        event = Event.get_by_slug('kif42')
+        form = AKSubmissionForm(data={'name': 'Test AK', 'event': event}, instance=None, initial={"event": event})
+        self.assertIn('types', form.fields,
+                      msg="Requirements field not present in form even though event has requirements")
+
+        event2 = Event.objects.create(name='Event without types',
+                                      slug='no_types',
+                                      start=datetime.now().astimezone(event.timezone),
+                                      end=datetime.now().astimezone(event.timezone),
+                                      active=True)
+        form2 = AKSubmissionForm(data={'name': 'Test AK', 'event': event2}, instance=None, initial={"event": event2})
+        self.assertNotIn('types', form2.fields,
+                         msg="Requirements field should not be present for events without types")

AKSubmission/urls.py

@@ -19,6 +19,7 @@ urlpatterns = [
             path('aks/', views.AKOverviewView.as_view(), name='ak_list'),
             path('aks/category/<int:category_pk>/', views.AKListByCategoryView.as_view(), name='ak_list_by_category'),
             path('aks/track/<int:track_pk>/', views.AKListByTrackView.as_view(), name='ak_list_by_track'),
+            path('aks/type/<slug:type_slug>/', views.AKListByTypeView.as_view(), name='ak_list_by_type'),
             path('owner/', views.AKOwnerCreateView.as_view(), name='akowner_create'),
             path('new/', views.AKOwnerSelectDispatchView.as_view(), name='akowner_select'),
             path('owner/edit/', views.AKOwnerEditDispatchView.as_view(), name='akowner_edit_dispatch'),

AKSubmission/views.py

-from datetime import timedelta
-from math import floor
 from abc import ABC, abstractmethod
+from datetime import datetime, timedelta
+from math import floor
 
 from django.apps import apps
 from django.conf import settings
@@ -8,19 +8,17 @@ from django.contrib import messages
 from django.http import HttpResponseRedirect
 from django.shortcuts import get_object_or_404, redirect
 from django.urls import reverse_lazy
-from django.utils.datetime_safe import datetime
 from django.utils.translation import gettext_lazy as _
 from django.views import View
-from django.views.generic import ListView, DetailView, CreateView, UpdateView, DeleteView, TemplateView
+from django.views.generic import CreateView, DeleteView, DetailView, ListView, TemplateView, UpdateView
 
 from AKModel.availability.models import Availability
 from AKModel.metaviews import status_manager
-from AKModel.metaviews.status import TemplateStatusWidget
-from AKModel.models import AK, AKCategory, AKOwner, AKSlot, AKTrack, AKOrgaMessage
 from AKModel.metaviews.admin import EventSlugMixin, FilterByEventSlugMixin
+from AKModel.metaviews.status import TemplateStatusWidget
+from AKModel.models import AK, AKCategory, AKOrgaMessage, AKOwner, AKSlot, AKTrack, AKType
 from AKSubmission.api import ak_interest_indication_active
-from AKSubmission.forms import AKWishForm, AKOwnerForm, AKSubmissionForm, AKDurationForm, AKOrgaMessageForm, \
-    AKForm
+from AKSubmission.forms import AKDurationForm, AKForm, AKOrgaMessageForm, AKOwnerForm, AKSubmissionForm, AKWishForm
 
 
 class SubmissionErrorNotConfiguredView(EventSlugMixin, TemplateView):
@@ -59,7 +57,7 @@ class AKOverviewView(FilterByEventSlugMixin, ListView):
         :rtype: QuerySet[AK]
         """
         # Use prefetching and relation selection/joining to reduce the amount of necessary queries
-        return category.ak_set.select_related('event').prefetch_related('owners').all()
+        return category.ak_set.select_related('event').prefetch_related('owners').prefetch_related('types').all()
 
     def get_active_category_name(self, context):
         """
@@ -130,6 +128,8 @@ class AKOverviewView(FilterByEventSlugMixin, ListView):
         context["active_category"] = self.get_active_category_name(context)
         context['table_title'] = self.get_table_title(context)
 
+        context['show_types'] = self.event.aktype_set.count() > 0
+
         # ==========================================================
         # Display interest indication button?
         # ==========================================================
@@ -181,10 +181,13 @@ class AKListByCategoryView(AKOverviewView):
 
     This view inherits from :class:`AKOverviewView`, but produces only one list instead of a tabbed one.
     """
+
     def dispatch(self, request, *args, **kwargs):
         # Override dispatching
         # Needed to handle the checking whether the category exists
-        self.category = get_object_or_404(AKCategory, pk=kwargs['category_pk']) # pylint: disable=attribute-defined-outside-init,line-too-long
+        # noinspection PyAttributeOutsideInit
+        # pylint: disable=attribute-defined-outside-init
+        self.category = get_object_or_404(AKCategory, pk=kwargs['category_pk'])
         return super().dispatch(request, *args, **kwargs)
 
     def get_active_category_name(self, context):
@@ -207,6 +210,7 @@ class AKListByTrackView(AKOverviewView):
     This view inherits from :class:`AKOverviewView` and there will be one list per category
     -- but only AKs of a certain given track will be included in them.
     """
+
     def dispatch(self, request, *args, **kwargs):
         # Override dispatching
         # Needed to handle the checking whether the track exists
@@ -231,6 +235,38 @@ class AKListByTrackView(AKOverviewView):
         return f"{_('AKs with Track')} = {self.track.name}"
 
 
+class AKListByTypeView(AKOverviewView):
+    """
+    View: List of only the AKs belonging to a certain type.
+
+    This view inherits from :class:`AKOverviewView` and there will be one list per category
+    -- but only AKs of a certain given type will be included in them.
+    """
+
+    def dispatch(self, request, *args, **kwargs):
+        # Override dispatching
+        # Needed to handle the checking whether the type exists
+
+        self.type = get_object_or_404(AKType, slug=kwargs['type_slug'])  # pylint: disable=attribute-defined-outside-init
+        return super().dispatch(request, *args, **kwargs)
+
+    def filter_aks(self, context, category):
+        """
+        Filter which AKs to display based on the given context and category
+
+        In this case, the list is further restricted by the type
+
+        :param context: context of the view
+        :param category: category to filter the AK list for
+        :return: filtered list of AKs for the given category
+        :rtype: QuerySet[AK]
+        """
+        return super().filter_aks(context, category).filter(types=self.type)
+
+    def get_table_title(self, context):
+        return f"{_('AKs with Type')} = {self.type.name}"
+
+
 class AKDetailView(EventSlugMixin, DetailView):
     """
     View: AK Details
@@ -241,7 +277,7 @@ class AKDetailView(EventSlugMixin, DetailView):
 
     def get_queryset(self):
         # Get information about the AK and do some query optimization
-        return super().get_queryset().select_related('event').prefetch_related('owners')
+        return super().get_queryset().select_related('event').prefetch_related('owners', 'akslot_set')
 
     def get_context_data(self, *, object_list=None, **kwargs):
         context = super().get_context_data(object_list=object_list, **kwargs)
@@ -290,6 +326,7 @@ class EventInactiveRedirectMixin:
     Will add a message explaining why the action was not performed to the user
     and then redirect to start page of the submission component
     """
+
     def get_error_message(self):
         """
         Error message to display after redirect (can be adjusted by this method)
@@ -349,6 +386,7 @@ class AKSubmissionView(AKAndAKWishSubmissionView):
 
     Extends :class:`AKAndAKWishSubmissionView`
     """
+
     def get_initial(self):
         # Load initial values for the form
         # Used to directly add the first owner and the event this AK will belong to
@@ -498,7 +536,6 @@ class AKOwnerDispatchView(ABC, EventSlugMixin, View):
         :rtype: HttpResponseRedirect
         """
 
-
     def post(self, request, *args, **kwargs):
         # This view is solely meant to handle POST requests
         # Perform dispatching based on the submitted owner_id

CONTRIBUTORS.md

@@ -17,3 +17,6 @@ Further contributions  in the form of code, testing, documentation etc. were mad
 * R. Zameitat [xayomer](https://gitlab.fachschaften.org/xayomer)
 * N. Steinger [voidptr](https://gitlab.fachschaften.org/voidptr)
 * T. Neumann [neumantm](https://gitlab.fachschaften.org/neumantm)
+* F. Blanke [felix_bonn](https://gitlab.fachschaften.org/felix_bonn)
+* L. Conti [lorax66](https://gitlab.fachschaften.org/lorax66)
+* M. Marx [mmarx](https://gitlab.fachschaften.org/mmarx)

INSTALL.md

@@ -10,7 +10,7 @@ setup.
 
 ### System Requirements
 
-* Python 3.8+ incl. development tools
+* Python3.11+ incl. development tools
 * Virtualenv
 * pdflatex & beamer
   class (`texlive-latex-base texlive-latex-recommended texlive-latex-extra texlive-fonts-extra texlive-luatex`)
@@ -37,7 +37,7 @@ Python requirements are listed in ``requirements.txt``. They can be installed wi
 
 ### Manual Setup
 
-1. setup a virtual environment using the proper python version ``virtualenv venv -p python3.7``
+1. setup a virtual environment using the proper python version ``virtualenv venv -p python3.11``
 1. activate virtualenv ``source venv/bin/activate``
 1. install python requirements ``pip install -r requirements.txt``
 1. setup necessary database tables etc. ``python manage.py migrate``
@@ -68,7 +68,7 @@ is not stored in any repository or similar, and disable DEBUG mode (``settings.p
 1. create a folder, e.g. ``mkdir /srv/AKPlanning/``
 1. change to the new directory ``cd /srv/AKPlanning/``
 1. clone this repository ``git clone URL .``
-1. setup a virtual environment using the proper python version ``virtualenv venv -p python3.7``
+1. setup a virtual environment using the proper python version ``virtualenv venv -p python3.11``
 1. activate virtualenv ``source venv/bin/activate``
 1. update tools ``pip install --upgrade setuptools pip wheel``
 1. install python requirements ``pip install -r requirements.txt``