Merge branch 'feature-modular-status' into 'main'

Split AKModel views into different files & introduce modular status page

See merge request !162

AKModel/admin.py

@@ -10,7 +10,6 @@ from django.utils import timezone
 from django.utils.html import format_html
 from django.utils.safestring import mark_safe
 from django.utils.translation import gettext_lazy as _
-from rest_framework.reverse import reverse
 from simple_history.admin import SimpleHistoryAdmin
 
 from AKModel.availability.models import Availability
@@ -18,8 +17,10 @@ from AKModel.forms import RoomFormWithAvailabilities
 from AKModel.models import Event, AKOwner, AKCategory, AKTrack, AKRequirement, AK, AKSlot, Room, AKOrgaMessage, \
     ConstraintViolation, DefaultSlot
 from AKModel.urls import get_admin_urls_event_wizard, get_admin_urls_event
-from AKModel.views import CVMarkResolvedView, CVSetLevelViolationView, CVSetLevelWarningView, AKResetInterestView, \
-    AKResetInterestCounterView, PlanPublishView, PlanUnpublishView, DefaultSlotEditorView, RoomBatchCreationView
+from AKModel.views.ak import AKResetInterestView, AKResetInterestCounterView
+from AKModel.views.manage import PlanPublishView, PlanUnpublishView, DefaultSlotEditorView, CVMarkResolvedView, \
+    CVSetLevelViolationView, CVSetLevelWarningView
+from AKModel.views.room import RoomBatchCreationView
 
 
 class EventRelatedFieldListFilter(RelatedFieldListFilter):
@@ -64,7 +65,7 @@ class EventAdmin(admin.ModelAdmin):
     @display(description=_("Status"))
     def status_url(self, obj):
         return format_html("<a href='{url}'>{text}</a>",
-                           url=reverse_lazy('admin:event_status', kwargs={'slug': obj.slug}), text=_("Status"))
+                           url=reverse_lazy('admin:event_status', kwargs={'event_slug': obj.slug}), text=_("Status"))
 
     @display(description=_("Toggle plan visibility"))
     def toggle_plan_visibility(self, obj):

AKModel/metaviews/__init__.py

+from AKModel.metaviews.status import StatusManager
+
+status_manager = StatusManager()

AKModel/metaviews/admin.py

+from abc import ABC, abstractmethod
+
+from django.contrib import admin, messages
+from django.shortcuts import get_object_or_404
+from django.urls import reverse
+from django.utils.translation import gettext_lazy as _
+from django.views.generic import FormView
+
+from AKModel.forms import AdminIntermediateForm, AdminIntermediateActionForm
+from AKModel.models import Event
+
+
+class EventSlugMixin:
+    """
+    Mixin to handle views with event slugs
+    """
+    event = None
+
+    def _load_event(self):
+        # Find event based on event slug
+        if self.event is None:
+            self.event = get_object_or_404(Event, slug=self.kwargs.get("event_slug", None))
+
+    def get(self, request, *args, **kwargs):
+        self._load_event()
+        return super().get(request, *args, **kwargs)
+
+    def post(self, request, *args, **kwargs):
+        self._load_event()
+        return super().post(request, *args, **kwargs)
+
+    def list(self, request, *args, **kwargs):
+        self._load_event()
+        return super().list(request, *args, **kwargs)
+
+    def create(self, request, *args, **kwargs):
+        self._load_event()
+        return super().create(request, *args, **kwargs)
+
+    def dispatch(self, request, *args, **kwargs):
+        if self.event is None:
+            self._load_event()
+        return super().dispatch(request, *args, **kwargs)
+
+    def get_context_data(self, *, object_list=None, **kwargs):
+        context = super().get_context_data(object_list=object_list, **kwargs)
+        # Add event to context (to make it accessible in templates)
+        context["event"] = self.event
+        return context
+
+
+class FilterByEventSlugMixin(EventSlugMixin):
+    """
+    Mixin to filter different querysets based on a event slug from the request url
+    """
+
+    def get_queryset(self):
+        # Filter current queryset based on url event slug or return 404 if event slug is invalid
+        return super().get_queryset().filter(event=self.event)
+
+
+class AdminViewMixin:
+    site_url = ''
+    title = ''
+
+    def get_context_data(self, **kwargs):
+        extra = admin.site.each_context(self.request)
+        extra.update(super().get_context_data(**kwargs))
+
+        if self.site_url != '':
+            extra["site_url"] = self.site_url
+        if self.title != '':
+            extra["title"] = self.title
+
+        return extra
+
+
+class IntermediateAdminView(AdminViewMixin, FormView):
+    template_name = "admin/AKModel/action_intermediate.html"
+    form_class = AdminIntermediateForm
+
+    def get_preview(self):
+        return ""
+
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        context["title"] = self.title
+        context["preview"] = self.get_preview()
+        return context
+
+
+class WizardViewMixin:
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        context["wizard_step"] = self.wizard_step
+        context["wizard_steps"] = [
+            _("Start"),
+            _("Settings"),
+            _("Event created, Prepare Import"),
+            _("Import categories & requirements"),
+            _("Activate?"),
+            _("Finish")
+        ]
+        context["wizard_step_text"] = context["wizard_steps"][self.wizard_step - 1]
+        context["wizard_steps_total"] = len(context["wizard_steps"])
+        return context
+
+
+class IntermediateAdminActionView(IntermediateAdminView, ABC):
+    form_class = AdminIntermediateActionForm
+    entities = None
+
+    def get_queryset(self, pks=None):
+        if pks is None:
+            pks = self.request.GET['pks']
+        return self.model.objects.filter(pk__in=pks.split(","))
+
+    def get_initial(self):
+        initial = super().get_initial()
+        initial['pks'] = self.request.GET['pks']
+        return initial
+
+    def get_preview(self):
+        self.entities = self.get_queryset()
+        joined_entities = '\n'.join(str(e) for e in self.entities)
+        return f"{self.confirmation_message}:\n\n {joined_entities}"
+
+    def get_success_url(self):
+        return reverse(f"admin:{self.model._meta.app_label}_{self.model._meta.model_name}_changelist")
+
+    @abstractmethod
+    def action(self, form):
+        pass
+
+    def form_valid(self, form):
+        self.entities = self.get_queryset(pks=form.cleaned_data['pks'])
+        self.action(form)
+        messages.add_message(self.request, messages.SUCCESS, self.success_message)
+        return super().form_valid(form)
+
+
+class LoopActionMixin(ABC):
+    def action(self, form):
+        self.pre_action()
+        for entity in self.entities:
+            self.perform_action(entity)
+            entity.save()
+        self.post_action()
+
+    @abstractmethod
+    def perform_action(self, entity):
+        pass
+
+    def pre_action(self):
+        pass
+
+    def post_action(self):
+        pass

AKModel/metaviews/status.py

+from abc import ABC, abstractmethod
+from collections import defaultdict
+
+from django.template import loader
+from django.views.generic import TemplateView
+
+from AKModel.metaviews.admin import AdminViewMixin
+
+
+class StatusWidget(ABC):
+    title = "Status Widget"
+    actions = []
+    status = "primary"
+
+    @property
+    @abstractmethod
+    def required_context_type(self) -> str:
+        """
+        Which model/context is needed to render this widget?
+        """
+        pass
+
+    def get_context_data(self, context) -> dict:
+        """
+        Allow to manipulate the context
+        :return: context (with or without changes)
+        """
+        return context
+
+    def render(self, context: {}, request) -> dict:
+        """
+        Render widget based on context
+
+        :param context: Context for rendering
+        :return: Dictionary containing the rendered/prepared information
+        """
+        context = self.get_context_data(context)
+        return {
+            "body": self.render_body(context, request),
+            "title": self.render_title(context),
+            "actions": self.render_actions(context),
+            "status": self.render_status(context),
+        }
+
+    def render_title(self, context: {}) -> str:
+        """
+        Render title for widget based on context
+
+        By default, the title attribute is used without modification
+        :param context: Context for rendering
+        :return: Rendered title
+        """
+        return self.title
+
+    def render_status(self, context: {}) -> str:
+        """
+        Render status for widget based on context
+
+        By default, the status attribute is used without modification
+        :param context: Context for rendering
+        :return: Rendered title
+        """
+        return self.status
+
+    @abstractmethod
+    def render_body(self, context: {}, request) -> str:
+        """
+        Render body for widget based on context
+
+        :param context: Context for rendering
+        :return: Rendered widget body (HTML)
+        """
+        pass
+
+    def render_actions(self, context: {}) -> list[dict]:
+        """
+        Render actions for widget based on context
+
+        By default, all actions specified for this widget are returned without modification
+
+        :param context: Context for rendering
+        :return: List of actions
+        """
+        return [a for a in self.actions]
+
+
+class TemplateStatusWidget(StatusWidget):
+    @property
+    @abstractmethod
+    def template_name(self) -> str:
+        pass
+
+    def render_body(self, context: {}, request) -> str:
+        template = loader.get_template(self.template_name)
+        return template.render(context, request)
+
+
+class StatusManager:
+    """
+    Registry for all status widgets
+    """
+    widgets = {}
+    widgets_by_context_type = defaultdict(list)
+
+    def register(self, name: str):
+        """
+        Call this as
+        @status_manager.register(name="xyz")
+        to register a status widget
+
+        :param name: name of this widget (only used internally). Has to be unique.
+        """
+        def _register(widget_class):
+            w = widget_class()
+            self.widgets[name] = w
+            self.widgets_by_context_type[w.required_context_type].append(w)
+            return widget_class
+
+        return _register
+
+    def get_by_context_type(self, context_type: str):
+        """
+        Filter widgets for ones suitable for provided context
+
+        :param context_type: name of the model provided as context
+        :return: a list of all matching widgets
+        """
+        if context_type in self.widgets_by_context_type.keys():
+            return self.widgets_by_context_type[context_type]
+        return []
+
+
+class StatusView(ABC, AdminViewMixin, TemplateView):
+    template_name = "admin/AKModel/status/status.html"
+
+    @property
+    @abstractmethod
+    def provided_context_type(self) -> str:
+        """
+        Which model/context is provided by this status view?
+        """
+        pass
+
+    def get(self, request, *args, **kwargs):
+        context = self.get_context_data(**kwargs)
+
+        from AKModel.metaviews import status_manager
+        context['widgets'] = [w.render(context, self.request) for w in status_manager.get_by_context_type(self.provided_context_type)]
+
+        return self.render_to_response(context)

AKModel/templates/admin/AKModel/render_ak_messages.html

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

AKModel/templates/admin/AKModel/status.html

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

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

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

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

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

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

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

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

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

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

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

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

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

AKModel/templates/admin/ak_index.html

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

AKModel/tests.py

@@ -156,7 +156,7 @@ class ModelViewTests(BasicViewTests, TestCase):
 
     VIEWS_STAFF_ONLY = [
         ('admin:index', {}),
-        ('admin:event_status', {'slug': 'kif42'}),
+        ('admin:event_status', {'event_slug': 'kif42'}),
         ('admin:event_requirement_overview', {'event_slug': 'kif42'}),
         ('admin:ak_csv_export', {'event_slug': 'kif42'}),
         ('admin:ak_wiki_export', {'slug': 'kif42'}),

AKModel/urls.py

@@ -3,18 +3,20 @@ from django.apps import apps
 from django.urls import include, path
 from rest_framework.routers import DefaultRouter
 
-from AKModel import views
-from AKModel.views import NewEventWizardStartView, NewEventWizardSettingsView, NewEventWizardPrepareImportView, \
-    NewEventWizardImportView, NewEventWizardActivateView, NewEventWizardFinishView, EventStatusView, \
-    AKRequirementOverview, AKCSVExportView, AKWikiExportView, AKMessageDeleteView, ExportSlidesView
+import AKModel.views.api
+from AKModel.views.manage import ExportSlidesView
+from AKModel.views.ak import AKRequirementOverview, AKCSVExportView, AKWikiExportView, AKMessageDeleteView
+from AKModel.views.event_wizard import NewEventWizardStartView, NewEventWizardPrepareImportView, \
+    NewEventWizardImportView, NewEventWizardActivateView, NewEventWizardFinishView, NewEventWizardSettingsView
+from AKModel.views.status import EventStatusView
 
 api_router = DefaultRouter()
-api_router.register('akowner', views.AKOwnerViewSet, basename='AKOwner')
-api_router.register('akcategory', views.AKCategoryViewSet, basename='AKCategory')
-api_router.register('aktrack', views.AKTrackViewSet, basename='AKTrack')
-api_router.register('ak', views.AKViewSet, basename='AK')
-api_router.register('room', views.RoomViewSet, basename='Room')
-api_router.register('akslot', views.AKSlotViewSet, basename='AKSlot')
+api_router.register('akowner', AKModel.views.api.AKOwnerViewSet, basename='AKOwner')
+api_router.register('akcategory', AKModel.views.api.AKCategoryViewSet, basename='AKCategory')
+api_router.register('aktrack', AKModel.views.api.AKTrackViewSet, basename='AKTrack')
+api_router.register('ak', AKModel.views.api.AKViewSet, basename='AK')
+api_router.register('room', AKModel.views.api.RoomViewSet, basename='Room')
+api_router.register('akslot', AKModel.views.api.AKSlotViewSet, basename='AKSlot')
 
 extra_paths = []
 if apps.is_installed("AKScheduling"):
@@ -48,7 +50,7 @@ urlpatterns = [
         '<slug:event_slug>/',
         include(event_specific_paths)
     ),
-    path('user/', views.UserView.as_view(), name="user"),
+    path('user/', AKModel.views.manage.UserView.as_view(), name="user"),
 ]
 
 
@@ -74,7 +76,7 @@ def get_admin_urls_event_wizard(admin_site):
 
 def get_admin_urls_event(admin_site):
     return [
-        path('<slug:slug>/status/', admin_site.admin_view(EventStatusView.as_view()), name="event_status"),
+        path('<slug:event_slug>/status/', admin_site.admin_view(EventStatusView.as_view()), name="event_status"),
         path('<slug:event_slug>/requirements/', admin_site.admin_view(AKRequirementOverview.as_view()),
              name="event_requirement_overview"),
         path('<slug:event_slug>/ak-csv-export/', admin_site.admin_view(AKCSVExportView.as_view()),

AKModel/views/ak.py

+from django.contrib import messages
+from django.urls import reverse_lazy
+from django.utils.translation import gettext_lazy as _
+from django.views.generic import ListView, DetailView
+
+from AKModel.metaviews.admin import AdminViewMixin, FilterByEventSlugMixin, EventSlugMixin, IntermediateAdminView, \
+    IntermediateAdminActionView
+from AKModel.models import AKRequirement, AKSlot, Event, AKOrgaMessage, AK
+
+
+class AKRequirementOverview(AdminViewMixin, FilterByEventSlugMixin, ListView):
+    model = AKRequirement
+    context_object_name = "requirements"
+    title = _("Requirements for Event")
+    template_name = "admin/AKModel/requirements_overview.html"
+
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        context["event"] = self.event
+        context["site_url"] = reverse_lazy("dashboard:dashboard_event", kwargs={'slug': context["event"].slug})
+        return context
+
+
+class AKCSVExportView(AdminViewMixin, FilterByEventSlugMixin, ListView):
+    template_name = "admin/AKModel/ak_csv_export.html"
+    model = AKSlot
+    context_object_name = "slots"
+    title = _("AK CSV Export")
+
+    def get_queryset(self):
+        return super().get_queryset().order_by("ak__track")
+
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        return context
+
+
+class AKWikiExportView(AdminViewMixin, DetailView):
+    template_name = "admin/AKModel/wiki_export.html"
+    model = Event
+    context_object_name = "event"
+    title = _("AK Wiki Export")
+
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+
+        categories_with_aks, ak_wishes = context["event"].get_categories_with_aks(
+            wishes_seperately=True,
+            filter=lambda ak: ak.include_in_export
+        )
+
+        context["categories_with_aks"] = [(category.name, ak_list) for category, ak_list in categories_with_aks]
+        context["categories_with_aks"].append((_("Wishes"), ak_wishes))
+
+        return context
+
+
+class AKMessageDeleteView(EventSlugMixin, IntermediateAdminView):
+    template_name = "admin/AKModel/message_delete.html"
+    title = _("Delete AK Orga Messages")
+
+    def get_orga_messages_for_event(self, event):
+        return AKOrgaMessage.objects.filter(ak__event=event)
+
+    def get_success_url(self):
+        return reverse_lazy('admin:event_status', kwargs={'slug': self.event.slug})
+
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        context["ak_messages"] = self.get_orga_messages_for_event(self.event)
+        return context
+
+    def form_valid(self, form):
+        self.get_orga_messages_for_event(self.event).delete()
+        messages.add_message(self.request, messages.SUCCESS, _("AK Orga Messages successfully deleted"))
+        return super().form_valid(form)
+
+
+class AKResetInterestView(IntermediateAdminActionView):
+    title = _("Reset interest in AKs")
+    model = AK
+    confirmation_message = _("Interest of the following AKs will be set to not filled (-1):")
+    success_message = _("Reset of interest in AKs successful.")
+
+    def action(self, form):
+        self.entities.update(interest=-1)
+
+
+class AKResetInterestCounterView(IntermediateAdminActionView):
+    title = _("Reset AKs' interest counters")
+    model = AK
+    confirmation_message = _("Interest counter of the following AKs will be set to 0:")
+    success_message = _("AKs' interest counters set back to 0.")
+
+    def action(self, form):
+        self.entities.update(interest_counter=0)

AKModel/views/api.py

+from rest_framework import mixins, viewsets, permissions
+
+from AKModel.metaviews.admin import EventSlugMixin
+from AKModel.models import AKOwner, AKCategory, AKTrack, AK, Room, AKSlot
+from AKModel.serializers import AKOwnerSerializer, AKCategorySerializer, AKTrackSerializer, AKSerializer, \
+    RoomSerializer, AKSlotSerializer
+
+
+class AKOwnerViewSet(EventSlugMixin, mixins.RetrieveModelMixin, mixins.ListModelMixin, viewsets.GenericViewSet):
+    permission_classes = (permissions.DjangoModelPermissionsOrAnonReadOnly,)
+    serializer_class = AKOwnerSerializer
+
+    def get_queryset(self):
+        return AKOwner.objects.filter(event=self.event)
+
+
+class AKCategoryViewSet(EventSlugMixin, mixins.RetrieveModelMixin, mixins.ListModelMixin, viewsets.GenericViewSet):
+    permission_classes = (permissions.DjangoModelPermissionsOrAnonReadOnly,)
+    serializer_class = AKCategorySerializer
+
+    def get_queryset(self):
+        return AKCategory.objects.filter(event=self.event)
+
+
+class AKTrackViewSet(EventSlugMixin, mixins.RetrieveModelMixin, mixins.CreateModelMixin, mixins.UpdateModelMixin,
+                     mixins.DestroyModelMixin, mixins.ListModelMixin, viewsets.GenericViewSet):
+    permission_classes = (permissions.DjangoModelPermissionsOrAnonReadOnly,)
+    serializer_class = AKTrackSerializer
+
+    def get_queryset(self):
+        return AKTrack.objects.filter(event=self.event)
+
+
+class AKViewSet(EventSlugMixin, mixins.RetrieveModelMixin, mixins.UpdateModelMixin, mixins.ListModelMixin,
+                viewsets.GenericViewSet):
+    permission_classes = (permissions.DjangoModelPermissionsOrAnonReadOnly,)
+    serializer_class = AKSerializer
+
+    def get_queryset(self):
+        return AK.objects.filter(event=self.event)
+
+
+class RoomViewSet(EventSlugMixin, mixins.RetrieveModelMixin, mixins.ListModelMixin, viewsets.GenericViewSet):
+    permission_classes = (permissions.DjangoModelPermissionsOrAnonReadOnly,)
+    serializer_class = RoomSerializer
+
+    def get_queryset(self):
+        return Room.objects.filter(event=self.event)
+
+
+class AKSlotViewSet(EventSlugMixin, mixins.RetrieveModelMixin, mixins.CreateModelMixin, mixins.UpdateModelMixin,
+                    mixins.ListModelMixin, viewsets.GenericViewSet):
+    permission_classes = (permissions.DjangoModelPermissionsOrAnonReadOnly,)
+    serializer_class = AKSlotSerializer
+
+    def get_queryset(self):
+        return AKSlot.objects.filter(event=self.event)

AKModel/views/event_wizard.py

+from django.apps import apps
+from django.contrib import messages
+from django.shortcuts import redirect
+from django.urls import reverse_lazy
+from django.utils.translation import gettext_lazy as _
+from django.views.generic import CreateView, FormView, UpdateView, DetailView
+
+from AKModel.forms import NewEventWizardStartForm, NewEventWizardSettingsForm, NewEventWizardPrepareImportForm, \
+    NewEventWizardImportForm, NewEventWizardActivateForm
+from AKModel.metaviews.admin import AdminViewMixin, WizardViewMixin, EventSlugMixin
+from AKModel.models import Event
+
+
+class NewEventWizardStartView(AdminViewMixin, WizardViewMixin, CreateView):
+    model = Event
+    form_class = NewEventWizardStartForm
+    template_name = "admin/AKModel/event_wizard/start.html"
+    wizard_step = 1
+
+
+class NewEventWizardSettingsView(AdminViewMixin, WizardViewMixin, CreateView):
+    model = Event
+    form_class = NewEventWizardSettingsForm
+    template_name = "admin/AKModel/event_wizard/settings.html"
+    wizard_step = 2
+
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        context["timezone"] = context["form"].cleaned_data["timezone"]
+        return context
+
+    def get_success_url(self):
+        return reverse_lazy("admin:new_event_wizard_prepare_import", kwargs={"event_slug": self.object.slug})
+
+
+class NewEventWizardPrepareImportView(WizardViewMixin, EventSlugMixin, FormView):
+    form_class = NewEventWizardPrepareImportForm
+    template_name = "admin/AKModel/event_wizard/created_prepare_import.html"
+    wizard_step = 3
+
+    def form_valid(self, form):
+        # Selected a valid event to import from? Use this to go to next step of wizard
+        return redirect("admin:new_event_wizard_import", event_slug=self.event.slug,
+                        import_slug=form.cleaned_data["import_event"].slug)
+
+
+class NewEventWizardImportView(EventSlugMixin, WizardViewMixin, FormView):
+    form_class = NewEventWizardImportForm
+    template_name = "admin/AKModel/event_wizard/import.html"
+    wizard_step = 4
+
+    def get_initial(self):
+        initial = super().get_initial()
+        initial["import_event"] = Event.objects.get(slug=self.kwargs["import_slug"])
+        return initial
+
+    def form_valid(self, form):
+        import_types = ["import_categories", "import_requirements"]
+        if apps.is_installed("AKDashboard"):
+            import_types.append("import_buttons")
+
+        for import_type in import_types:
+            for import_obj in form.cleaned_data.get(import_type):
+                # clone existing entry
+                try:
+                    import_obj.event = self.event
+                    import_obj.pk = None
+                    import_obj.save()
+                    messages.add_message(self.request, messages.SUCCESS, _("Copied '%(obj)s'" % {'obj': import_obj}))
+                except BaseException as e:
+                    messages.add_message(self.request, messages.ERROR,
+                                         _("Could not copy '%(obj)s' (%(error)s)" % {'obj': import_obj,
+                                                                                     "error": str(e)}))
+        return redirect("admin:new_event_wizard_activate", slug=self.event.slug)
+
+
+class NewEventWizardActivateView(WizardViewMixin, UpdateView):
+    model = Event
+    template_name = "admin/AKModel/event_wizard/activate.html"
+    form_class = NewEventWizardActivateForm
+    wizard_step = 5
+
+    def get_success_url(self):
+        return reverse_lazy("admin:new_event_wizard_finish", kwargs={"slug": self.object.slug})
+
+
+class NewEventWizardFinishView(WizardViewMixin, DetailView):
+    model = Event
+    template_name = "admin/AKModel/event_wizard/finish.html"
+    wizard_step = 6