AKModel/metaviews/admin.py

@@ -13,36 +13,61 @@ from AKModel.models import Event
 class EventSlugMixin:
     """
     Mixin to handle views with event slugs
+
+    This will make the relevant event available as self.event in all kind types of requests
+    (generic GET and POST views, list views, dispatching, create views)
     """
+    # pylint: disable=no-member
     event = None
 
     def _load_event(self):
+        """
+        Perform the real loading of the event data (as specified by event_slug in the URL) into self.event
+        """
         # 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):
+        """
+        Override GET request handling to perform loading event first
+        """
         self._load_event()
         return super().get(request, *args, **kwargs)
 
     def post(self, request, *args, **kwargs):
+        """
+        Override POST request handling to perform loading event first
+        """
         self._load_event()
         return super().post(request, *args, **kwargs)
 
     def list(self, request, *args, **kwargs):
+        """
+        Override list view request handling to perform loading event first
+        """
         self._load_event()
         return super().list(request, *args, **kwargs)
 
     def create(self, request, *args, **kwargs):
+        """
+        Override create view request handling to perform loading event first
+        """
         self._load_event()
         return super().create(request, *args, **kwargs)
 
     def dispatch(self, request, *args, **kwargs):
+        """
+        Override dispatch which is called in many generic views to perform loading event first
+        """
         if self.event is None:
             self._load_event()
         return super().dispatch(request, *args, **kwargs)
 
     def get_context_data(self, *, object_list=None, **kwargs):
+        """
+        Override `get_context_data` to make the event information available in the rendering context as `event`. too
+        """
         context = super().get_context_data(object_list=object_list, **kwargs)
         # Add event to context (to make it accessible in templates)
         context["event"] = self.event
@@ -55,15 +80,29 @@ class FilterByEventSlugMixin(EventSlugMixin):
     """
 
     def get_queryset(self):
-        # Filter current queryset based on url event slug or return 404 if event slug is invalid
+        """
+        Get adapted queryset:
+        Filter current queryset based on url event slug or return 404 if event slug is invalid
+        :return: Queryset
+        """
         return super().get_queryset().filter(event=self.event)
 
 
 class AdminViewMixin:
+    """
+    Mixin to provide context information needed in custom admin views
+
+    Will either use default information for `site_url` and `title` or allows to set own values for that
+    """
+    # pylint: disable=too-few-public-methods
+
     site_url = ''
     title = ''
 
     def get_context_data(self, **kwargs):
+        """
+        Extend context
+        """
         extra = admin.site.each_context(self.request)
         extra.update(super().get_context_data(**kwargs))
 
@@ -76,10 +115,19 @@ class AdminViewMixin:
 
 
 class IntermediateAdminView(AdminViewMixin, FormView):
+    """
+    Metaview: Handle typical "action but with preview and confirmation step before" workflow
+    """
     template_name = "admin/AKModel/action_intermediate.html"
     form_class = AdminIntermediateForm
 
     def get_preview(self):
+        """
+        Render a preview of the action to be performed.
+        Default is empty
+        :return: preview (html)
+        :rtype: str
+        """
         return ""
 
     def get_context_data(self, **kwargs):
@@ -90,7 +138,18 @@ class IntermediateAdminView(AdminViewMixin, FormView):
 
 
 class WizardViewMixin:
+    """
+    Mixin to create wizard-like views.
+    This visualizes the progress of the user in the creation process and provides the interlinking to the next step
+
+    In the current implementation, the steps of the wizard are hardcoded here,
+    hence this mixin can only be used for the event creation wizard
+    """
+    # pylint: disable=too-few-public-methods
     def get_context_data(self, **kwargs):
+        """
+        Extend context
+        """
         context = super().get_context_data(**kwargs)
         context["wizard_step"] = self.wizard_step
         context["wizard_steps"] = [
@@ -107,10 +166,23 @@ class WizardViewMixin:
 
 
 class IntermediateAdminActionView(IntermediateAdminView, ABC):
+    """
+    Abstract base view: Intermediate action view (preview & confirmation see :class:`IntermediateAdminView`)
+    for custom admin actions (marking multiple objects in a django admin model instances list with a checkmark and then
+    choosing an action from the dropdown).
+
+    This will automatically handle the decoding of the URL encoding of the list of primary keys django does to select
+    which objects the action should be run on, then display a preview, perform the action after confirmation and
+    redirect again to the object list including display of a confirmation message
+    """
+    # pylint: disable=no-member
     form_class = AdminIntermediateActionForm
     entities = None
 
     def get_queryset(self, pks=None):
+        """
+        Get the queryset of objects to perform the action on
+        """
         if pks is None:
             pks = self.request.GET['pks']
         return self.model.objects.filter(pk__in=pks.split(","))
@@ -130,7 +202,10 @@ class IntermediateAdminActionView(IntermediateAdminView, ABC):
 
     @abstractmethod
     def action(self, form):
-        pass
+        """
+        The real action to perform
+        :param form: form holding the data probably needed for the action
+        """
 
     def form_valid(self, form):
         self.entities = self.get_queryset(pks=form.cleaned_data['pks'])
@@ -140,7 +215,21 @@ class IntermediateAdminActionView(IntermediateAdminView, ABC):
 
 
 class LoopActionMixin(ABC):
-    def action(self, form):
+    """
+    Mixin for the typical kind of action where one needs to loop over all elements
+    and perform a certain function on each of them
+
+    The action is performed by overriding `perform_action(self, entity)`
+    further customization can be reached with the two callbacks `pre_action()` and `post_action()`
+    that are called before and after performing the action loop
+    """
+    def action(self, form):  # pylint: disable=unused-argument
+        """
+        The real action to perform.
+        Will perform the loop, perform the action on each aelement and call the callbacks
+
+        :param form: form holding the data probably needed for the action
+        """
         self.pre_action()
         for entity in self.entities:
             self.perform_action(entity)
@@ -149,10 +238,18 @@ class LoopActionMixin(ABC):
 
     @abstractmethod
     def perform_action(self, entity):
-        pass
+        """
+        Action to perform on each entity
+
+        :param entity: entity to perform the action on
+        """
 
     def pre_action(self):
-        pass
+        """
+        Callback for custom action before loop starts
+        """
 
     def post_action(self):
-        pass
+        """
+        Callback for custom action after loop finished
+        """

AKModel/metaviews/status.py

@@ -8,6 +8,9 @@ from AKModel.metaviews.admin import AdminViewMixin
 
 
 class StatusWidget(ABC):
+    """
+    Abstract parent for status page widgets
+    """
     title = "Status Widget"
     actions = []
     status = "primary"
@@ -18,7 +21,6 @@ class StatusWidget(ABC):
         """
         Which model/context is needed to render this widget?
         """
-        pass
 
     def get_context_data(self, context) -> dict:
         """
@@ -32,6 +34,7 @@ class StatusWidget(ABC):
         Render widget based on context
 
         :param context: Context for rendering
+        :param request: HTTP request, needed for rendering
         :return: Dictionary containing the rendered/prepared information
         """
         context = self.get_context_data(context)
@@ -42,7 +45,7 @@ class StatusWidget(ABC):
             "status": self.render_status(context),
         }
 
-    def render_title(self, context: {}) -> str:
+    def render_title(self, context: {}) -> str:  # pylint: disable=unused-argument
         """
         Render title for widget based on context
 
@@ -52,7 +55,7 @@ class StatusWidget(ABC):
         """
         return self.title
 
-    def render_status(self, context: {}) -> str:
+    def render_status(self, context: {}) -> str:  # pylint: disable=unused-argument
         """
         Render status for widget based on context
 
@@ -63,16 +66,16 @@ class StatusWidget(ABC):
         return self.status
 
     @abstractmethod
-    def render_body(self, context: {}, request) -> str:
+    def render_body(self, context: {}, request) -> str:  # pylint: disable=unused-argument
         """
         Render body for widget based on context
 
         :param context: Context for rendering
+        :param request: HTTP request (needed for rendering)
         :return: Rendered widget body (HTML)
         """
-        pass
 
-    def render_actions(self, context: {}) -> list[dict]:
+    def render_actions(self, context: {}) -> list[dict]:  # pylint: disable=unused-argument
         """
         Render actions for widget based on context
 
@@ -81,16 +84,30 @@ class StatusWidget(ABC):
         :param context: Context for rendering
         :return: List of actions
         """
-        return [a for a in self.actions]
+        return self.actions
 
 
 class TemplateStatusWidget(StatusWidget):
+    """
+    A :class:`StatusWidget` that produces its content by rendering a given html template
+    """
     @property
     @abstractmethod
     def template_name(self) -> str:
-        pass
+        """
+        Configure the template to use
+        :return: name of the template to use
+        """
 
     def render_body(self, context: {}, request) -> str:
+        """
+        Render the body of the widget using the template rendering method from django
+        (load and render template using the provided context)
+
+        :param context: context to use for rendering
+        :param request: HTTP request (needed by django)
+        :return: rendered content (HTML)
+        """
         template = loader.get_template(self.template_name)
         return template.render(context, request)
 
@@ -98,6 +115,8 @@ class TemplateStatusWidget(StatusWidget):
 class StatusManager:
     """
     Registry for all status widgets
+
+    Allows to register status widgets using the `@status_manager.register(name="xyz")` decorator
     """
     widgets = {}
     widgets_by_context_type = defaultdict(list)
@@ -131,6 +150,9 @@ class StatusManager:
 
 
 class StatusView(ABC, AdminViewMixin, TemplateView):
+    """
+    Abstract view: A generic base view to create a status page holding multiple widgets
+    """
     template_name = "admin/AKModel/status/status.html"
 
     @property
@@ -139,12 +161,15 @@ class StatusView(ABC, AdminViewMixin, TemplateView):
         """
         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)]
+        # Load status manager (local import to prevent cyclic import)
+        from AKModel.metaviews import status_manager  # pylint: disable=import-outside-toplevel
+
+        # Render all widgets and provide them as part of the context
+        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/migrations/0059_interest_default.py

+# Generated by Django 4.2.11 on 2024-04-21 14:54
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('AKModel', '0058_alter_ak_options'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='event',
+            name='interest_start',
+            field=models.DateTimeField(blank=True, help_text='Opening time for expression of interest. When left blank, no interest indication will be possible.', null=True, verbose_name='Interest Window Start'),
+        ),
+    ]

AKModel/migrations/0060_orga_message_resolved.py

+# Generated by Django 4.2.11 on 2024-04-24 21:39
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('AKModel', '0059_interest_default'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='akorgamessage',
+            name='resolved',
+            field=models.BooleanField(default=False, help_text='This message has been resolved (no further action needed)', verbose_name='Resolved'),
+        ),
+    ]

AKModel/migrations/0061_types.py

+# Generated by Django 4.2.13 on 2025-02-25 20:58
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('AKModel', '0060_orga_message_resolved'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='AKType',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(help_text='Name describing the type', max_length=128, verbose_name='Name')),
+                ('event', models.ForeignKey(help_text='Associated event', on_delete=django.db.models.deletion.CASCADE, to='AKModel.event', verbose_name='Event')),
+            ],
+            options={
+                'verbose_name': 'AK Type',
+                'verbose_name_plural': 'AK Types',
+                'ordering': ['name'],
+                'unique_together': {('event', 'name')},
+            },
+        ),
+        migrations.AddField(
+            model_name='ak',
+            name='types',
+            field=models.ManyToManyField(blank=True, help_text='This AK is', to='AKModel.aktype', verbose_name='Types'),
+        ),
+    ]

AKModel/migrations/0062_interest_no_history.py

+# Generated by Django 4.2.13 on 2025-02-26 22:35
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('AKModel', '0061_types'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='historicalak',
+            name='interest',
+        ),
+    ]

AKModel/migrations/0063_field_validators.py

+# Generated by Django 4.2.13 on 2025-03-03 19:59
+
+import django.core.validators
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('AKModel', '0062_interest_no_history'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='ak',
+            name='name',
+            field=models.CharField(help_text='Name of the AK', max_length=256, validators=[django.core.validators.RegexValidator(inverse_match=True, message='May not contain quotation marks', regex='[\'\\"´`]+'), django.core.validators.RegexValidator(message='Must contain at least one letter or digit', regex='[\\w\\s]+')], verbose_name='Name'),
+        ),
+        migrations.AlterField(
+            model_name='ak',
+            name='short_name',
+            field=models.CharField(blank=True, help_text='Name displayed in the schedule', max_length=64, validators=[django.core.validators.RegexValidator(inverse_match=True, message='May not contain quotation marks', regex='[\'\\"´`]+')], verbose_name='Short Name'),
+        ),
+        migrations.AlterField(
+            model_name='akowner',
+            name='name',
+            field=models.CharField(help_text='Name to identify an AK owner by', max_length=64, validators=[django.core.validators.RegexValidator(inverse_match=True, message='May not contain quotation marks', regex='[\'\\"´`]+'), django.core.validators.RegexValidator(message='Must contain at least one letter or digit', regex='[\\w\\s]+')], verbose_name='Nickname'),
+        ),
+        migrations.AlterField(
+            model_name='historicalak',
+            name='name',
+            field=models.CharField(help_text='Name of the AK', max_length=256, validators=[django.core.validators.RegexValidator(inverse_match=True, message='May not contain quotation marks', regex='[\'\\"´`]+'), django.core.validators.RegexValidator(message='Must contain at least one letter or digit', regex='[\\w\\s]+')], verbose_name='Name'),
+        ),
+        migrations.AlterField(
+            model_name='historicalak',
+            name='short_name',
+            field=models.CharField(blank=True, help_text='Name displayed in the schedule', max_length=64, validators=[django.core.validators.RegexValidator(inverse_match=True, message='May not contain quotation marks', regex='[\'\\"´`]+')], verbose_name='Short Name'),
+        ),
+    ]

AKModel/serializers.py

@@ -4,36 +4,54 @@ from AKModel.models import AK, Room, AKSlot, AKTrack, AKCategory, AKOwner
 
 
 class AKOwnerSerializer(serializers.ModelSerializer):
+    """
+    REST Framework Serializer for AKOwner
+    """
     class Meta:
         model = AKOwner
         fields = '__all__'
 
 
 class AKCategorySerializer(serializers.ModelSerializer):
+    """
+    REST Framework Serializer for AKCategory
+    """
     class Meta:
         model = AKCategory
         fields = '__all__'
 
 
 class AKTrackSerializer(serializers.ModelSerializer):
+    """
+    REST Framework Serializer for AKTrack
+    """
     class Meta:
         model = AKTrack
         fields = '__all__'
 
 
 class AKSerializer(serializers.ModelSerializer):
+    """
+    REST Framework Serializer for AK
+    """
     class Meta:
         model = AK
         fields = '__all__'
 
 
 class RoomSerializer(serializers.ModelSerializer):
+    """
+    REST Framework Serializer for Room
+    """
     class Meta:
         model = Room
         fields = '__all__'
 
 
 class AKSlotSerializer(serializers.ModelSerializer):
+    """
+    REST Framework Serializer for AKSlot
+    """
     class Meta:
         model = AKSlot
         fields = '__all__'
@@ -41,6 +59,9 @@ class AKSlotSerializer(serializers.ModelSerializer):
     treat_as_local = serializers.BooleanField(required=False, default=False, write_only=True)
 
     def create(self, validated_data:dict):
+        # Handle timezone adaption based upon the control field "treat_as_local":
+        # If it is set, ignore timezone submitted from the browser (will always be UTC)
+        # and treat it as input in the events timezone instead
         if validated_data['treat_as_local']:
             validated_data['start'] = validated_data['start'].replace(tzinfo=None).astimezone(
                 validated_data['event'].timezone)

AKModel/site.py

 from django.contrib.admin import AdminSite
 from django.utils.translation import gettext_lazy as _
+# from django.urls import path
 
 from AKModel.models import Event
 
 
 class AKAdminSite(AdminSite):
+    """
+    Custom admin interface definition (extend the admin functionality of Django)
+    """
     index_template = "admin/ak_index.html"
     site_header = f"AKPlanning - {_('Administration')}"
     index_title = _('Administration')
 
     def get_urls(self):
-        from django.urls import path
-
+        """
+        Get URLs -- add further views that are not related to a certain model here if needed
+        """
         urls = super().get_urls()
         urls += [
             # path('...', self.admin_view(...)),
@@ -19,6 +24,8 @@ class AKAdminSite(AdminSite):
         return urls
 
     def index(self, request, extra_context=None):
+        # Override index page rendering to provide extra context (the list of active events)
+        # to be used in the adapted template
         if extra_context is None:
             extra_context = {}
         extra_context["active_events"] = Event.objects.filter(active=True)

AKModel/templates/admin/AKModel/ak_csv_export.html

@@ -4,8 +4,8 @@
 
 {% block content %}
 <pre>
-title;duration;who;requirements;prerequisites;conflicts;availabilities;category;track;reso;notes;
-{% for slot in slots %}{{ slot.ak.short_name }};{{ slot.duration }};{{ slot.ak.owners.all|join:", " }};{{ slot.ak.requirements.all|join:", " }};{{ slot.ak.prerequisites.all|join:", " }};{{ slot.ak.conflicts.all|join:", " }};{% for a in slot.ak.availabilities.all %}{{ a.start | timezone:event.timezone | date:"l H:i"  }} - {{ a.end | timezone:event.timezone | date:"l H:i" }}, {% endfor %};{{ slot.ak.category }};{{ slot.ak.track }};{{ slot.ak.reso }};{{ slot.ak.notes }};
+title;duration;who;requirements;prerequisites;conflicts;availabilities;category;types;track;reso;notes;
+{% for slot in slots %}{{ slot.ak.short_name }};{{ slot.duration }};{{ slot.ak.owners.all|join:", " }};{{ slot.ak.requirements.all|join:", " }};{{ slot.ak.prerequisites.all|join:", " }};{{ slot.ak.conflicts.all|join:", " }};{% for a in slot.ak.availabilities.all %}{{ a.start | timezone:event.timezone | date:"l H:i"  }} - {{ a.end | timezone:event.timezone | date:"l H:i" }}, {% endfor %};{{ slot.ak.category }};{{ slot.ak.types.all|join:", " }};{{ slot.ak.track }};{{ slot.ak.reso }};{{ slot.ak.notes }};
 {% endfor %}
 </pre>
 {% endblock %}

AKModel/templates/admin/AKModel/aks_by_user.html

+{% extends "admin/base_site.html" %}
+{% load tags_AKModel %}
+
+{% load i18n %}
+{% load tz %}
+{% load fontawesome_6 %}
+
+{% block title %}{% trans "AKs by Owner" %}: {{owner}}{% endblock %}
+
+{% block content %}
+    {% timezone event.timezone %}
+        <h2>[{{event}}] <a href="{% url 'admin:AKModel_akowner_change' owner.pk %}">{{owner}}</a> - {% trans "AKs" %}</h2>
+
+        <div class="row mt-4">
+            <table class="table table-striped">
+                {% for ak in owner.ak_set.all %}
+                    <tr>
+                        <td>{{ ak }}</td>
+                        {% if "AKSubmission"|check_app_installed %}
+                            <td class="text-end">
+                                <a href="{{ ak.detail_url }}" data-bs-toggle="tooltip"
+                                   title="{% trans 'Details' %}"
+                                   class="btn btn-primary">{% fa6_icon 'info' 'fas' %}</a>
+                                {% if event.active %}
+                                    <a href="{{ ak.edit_url }}" data-bs-toggle="tooltip"
+                                       title="{% trans 'Edit' %}"
+                                       class="btn btn-success">{% fa6_icon 'pencil-alt' 'fas' %}</a>
+                                {% endif %}
+                            {% endif %}
+                        </td>
+                    </tr>
+                {% empty %}
+                    <tr><td>{% trans "This user does not have any AKs currently" %}</td></tr>
+                {% endfor %}
+            </table>
+        </div>
+    {% endtimezone %}
+{% endblock %}

AKModel/templates/admin/AKModel/event_wizard/activate.html

@@ -8,6 +8,11 @@
 
 {% block title %}{% trans "New event wizard" %}: {{ wizard_step_text }}{% endblock %}
 
+{% block extrahead %}
+    {{ block.super }}
+    {{ form.media }}
+{% endblock %}
+
 {% block content %}
     {% include "admin/AKModel/event_wizard/wizard_steps.html" %}
 
@@ -17,8 +22,6 @@
 
     <h5 class="mb-3">{% trans "Successfully imported.<br><br>Do you want to activate your event now?" %}</h5>
 
-    {{ form.media }}
-
     <form method="post">{% csrf_token %}
         {% bootstrap_form form %}
 

AKModel/templates/admin/AKModel/event_wizard/created_prepare_import.html

@@ -8,6 +8,11 @@
 
 {% block title %}{% trans "New event wizard" %}: {{ wizard_step_text }}{% endblock %}
 
+{% block extrahead %}
+    {{ block.super }}
+    {{ form.media }}
+{% endblock %}
+
 {% block content %}
     {% include "admin/AKModel/event_wizard/wizard_steps.html" %}
 
@@ -29,8 +34,6 @@
 
     <h5 class="mb-3">{% trans "Your event was created and can now be further configured." %}</h5>
 
-    {{ form.media }}
-
     <form method="post">{% csrf_token %}
         {% bootstrap_form form %}
 

AKModel/templates/admin/AKModel/event_wizard/import.html

@@ -8,11 +8,14 @@
 
 {% block title %}{% trans "New event wizard" %}: {{ wizard_step_text }}{% endblock %}
 
+{% block extrahead %}
+    {{ block.super }}
+    {{ form.media }}
+{% endblock %}
+
 {% block content %}
     {% include "admin/AKModel/event_wizard/wizard_steps.html" %}
 
-    {{ form.media }}
-
     <form method="post">{% csrf_token %}
         {% bootstrap_form form %}
 

AKModel/templates/admin/AKModel/event_wizard/settings.html

@@ -8,11 +8,14 @@
 
 {% block title %}{% trans "New event wizard" %}: {{ wizard_step_text }}{% endblock %}
 
+{% block extrahead %}
+    {{ block.super }}
+    {{ form.media }}
+{% endblock %}
+
 {% block content %}
     {% include "admin/AKModel/event_wizard/wizard_steps.html" %}
 
-    {{ form.media }}
-
     {% timezone timezone %}
 
     <form method="post">{% csrf_token %}

AKModel/templates/admin/AKModel/event_wizard/start.html

@@ -7,6 +7,11 @@
 
 {% block title %}{% trans "New event wizard" %}: {{ wizard_step_text }}{% endblock %}
 
+{% block extrahead %}
+    {{ block.super }}
+    {{ form.media }}
+{% endblock %}
+
 {% block content %}
     {% include "admin/AKModel/event_wizard/wizard_steps.html" %}
 

AKModel/templates/admin/AKModel/render_ak_messages.html

 {% load tz %}
+{% load fontawesome_6 %}
 
 {% timezone event.timezone %}
     <table class="table table-striped">
@@ -7,7 +8,10 @@
             <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>
+            <h5><a href="{{ message.ak.detail_url }}">
+                {% if message.resolved %}{% fa6_icon "check-circle" %} {% endif %}
+                {{ message.ak }}
+            </a></h5>
             <p>{{ message.text }}</p>
         </td></tr>
     {% endfor %}

AKModel/templatetags/tags_AKModel.py

@@ -3,35 +3,65 @@ from django.apps import apps
 from django.conf import settings
 from django.utils.html import format_html, mark_safe, conditional_escape
 from django.templatetags.static import static
+from django.template.defaultfilters import date
 from fontawesome_6.app_settings import get_css
 
+from AKModel.models import Event
+
 register = template.Library()
 
 
-# Get Footer Info from settings
 @register.simple_tag
 def footer_info():
+    """
+    Get Footer Info from settings
+
+    :return: a dict of several strings like the impress URL to use in the footer
+    :rtype: Dict[str, str]
+    """
     return settings.FOOTER_INFO
 
 
 @register.filter
 def check_app_installed(name):
+    """
+    Check whether the app with the given name is active in this instance
+
+    :param name: name of the app to check for
+    :return: true if app is installed
+    :rtype: bool
+    """
     return apps.is_installed(name)
 
 
 @register.filter
 def message_bootstrap_class(tag):
+    """
+    Turn message severity classes into corresponding bootstrap css classes
+
+    :param tag: severity of the message
+    :return: matching bootstrap class
+    """
     if tag == "error":
         return "alert-danger"
-    elif tag == "success":
+    if tag == "success":
         return "alert-success"
-    elif tag == "warning":
+    if tag == "warning":
         return "alert-warning"
     return "alert-info"
 
 
 @register.filter
 def wiki_owners_export(owners, event):
+    """
+    Preserve owner link information for wiki export by using internal links if possible
+    but external links when owner specified a non-wikilink. This is applied to the full list of owners
+
+    :param owners: list of owners
+    :param event: event this owner belongs to and that is currently exported (specifying this directly prevents unnecessary database lookups) #pylint: disable=line-too-long
+    :return: linkified owners list in wiki syntax
+    :rtype: str
+    """
     def to_link(owner):
         if owner.link != '':
             event_link_prefix, _ = event.base_url.rsplit("/", 1)
@@ -44,17 +74,45 @@ def wiki_owners_export(owners, event):
     return ", ".join(to_link(owner) for owner in owners.all())
 
 
+@register.filter
+def event_month_year(event:Event):
+    """
+    Print rough event date (month and year)
+    :param event: event to print the date for
+    :return: string containing rough date information for event
+    """
+    if event.start.month == event.end.month:
+        return f"{date(event.start, 'F')} {event.start.year}"
+    event_start_string = date(event.start, 'F')
+    if event.start.year != event.end.year:
+        event_start_string = f"{event_start_string} {event.start.year}"
+    return f"{event_start_string} - {date(event.end, 'F')} {event.end.year}"
+
+
+# get list of relevant css fontawesome css files for this instance
 css = get_css()
 
 
 @register.simple_tag
 def fontawesome_6_css():
+    """
+    Create html code to load all required fontawesome css files
+
+    :return: HTML code to load css
+    :rtype: str
+    """
     return mark_safe(conditional_escape('\n').join(format_html(
             '<link href="{}" rel="stylesheet" media="all">', stylesheet) for stylesheet in css))
 
 
 @register.simple_tag
 def fontawesome_6_js():
+    """
+    Create html code to load all required fontawesome javascript files
+
+    :return: HTML code to load js
+    :rtype: str
+    """
     return mark_safe(format_html(
         '<script type="text/javascript" src="{}"></script>', static('fontawesome_6/js/django-fontawesome.js')
-    ))
\ No newline at end of file
+    ))

AKModel/tests.py

 import traceback
 from typing import List
 
-from django.contrib.auth.models import User
+from django.contrib.auth import get_user_model
 from django.contrib.messages import get_messages
 from django.contrib.messages.storage.base import Message
 from django.test import TestCase
@@ -12,21 +12,43 @@ from AKModel.models import Event, AKOwner, AKCategory, AKTrack, AKRequirement, A
 
 
 class BasicViewTests:
+    """
+    Parent class for "standard" tests of views
+
+    Provided with a list of views and arguments (if necessary), this will test that views
+    - render correctly without errors
+    - are only reachable with the correct rights (neither too freely nor too restricted)
+
+    To do this, the test creates sample users, fixtures are loaded automatically by the django test framework.
+    It also provides helper functions, e.g., to check for correct messages to the user or more simply generate
+    the URLs to test
+
+    In this class, methods from :class:`TestCase` will be called at multiple places event though TestCase is not a
+    parent of this class but has to be included as parent in concrete implementations of this class seperately.
+    It however still makes sense to treat this class as some kind of mixin and not implement it as a child of TestCase,
+    since the test framework does not understand the concept of abstract test definitions and would handle this class
+    as real test case otherwise, distorting the test results.
+    """
+    # pylint: disable=no-member
     VIEWS = []
     APP_NAME = ''
     VIEWS_STAFF_ONLY = []
     EDIT_TESTCASES = []
 
-    def setUp(self):
-        self.staff_user = User.objects.create(
+    def setUp(self):  # pylint: disable=invalid-name
+        """
+        Setup testing by creating sample users
+        """
+        user_model = get_user_model()
+        self.staff_user = user_model.objects.create(
             username='Test Staff User', email='teststaff@example.com', password='staffpw',
             is_staff=True, is_active=True
         )
-        self.admin_user = User.objects.create(
+        self.admin_user = user_model.objects.create(
             username='Test Admin User', email='testadmin@example.com', password='adminpw',
             is_staff=True, is_superuser=True, is_active=True
         )
-        self.deactivated_user = User.objects.create(
+        self.deactivated_user = user_model.objects.create(
             username='Test Deactivated User', email='testdeactivated@example.com', password='deactivatedpw',
             is_staff=True, is_active=False
         )
@@ -45,6 +67,13 @@ class BasicViewTests:
         return view_name_with_prefix, url
 
     def _assert_message(self, response, expected_message, msg_prefix=""):
+        """
+        Assert that the correct message is shown and cause test to fail if not
+
+        :param response: response to check
+        :param expected_message: message that should be shown
+        :param msg_prefix: prefix for the error message when test fails
+        """
         messages:List[Message] = list(get_messages(response.wsgi_request))
 
         msg_count = "No message shown to user"
@@ -59,60 +88,83 @@ class BasicViewTests:
         self.assertEqual(messages[-1].message, expected_message, msg=msg_content)
 
     def test_views_for_200(self):
+        """
+        Test the list of public views (as specified in "VIEWS") for error-free rendering
+        """
         for view_name in self.VIEWS:
             view_name_with_prefix, url = self._name_and_url(view_name)
             try:
                 response = self.client.get(url)
                 self.assertEqual(response.status_code, 200, msg=f"{view_name_with_prefix} ({url}) broken")
-            except Exception as e:
-                self.fail(f"An error occurred during rendering of {view_name_with_prefix} ({url}):\n\n{traceback.format_exc()}")
+            except Exception: # pylint: disable=broad-exception-caught
+                self.fail(f"An error occurred during rendering of {view_name_with_prefix} ({url}):"
+                          f"\n\n{traceback.format_exc()}")
 
     def test_access_control_staff_only(self):
+        """
+        Test whether internal views (as specified in "VIEWS_STAFF_ONLY" are visible to staff users and staff users only
+        """
+        # Not logged in? Views should not be visible
         self.client.logout()
-        for view_name in self.VIEWS_STAFF_ONLY:
-            view_name_with_prefix, url = self._name_and_url(view_name)
+        for view_name_info in self.VIEWS_STAFF_ONLY:
+            expected_response_code = 302 if len(view_name_info) == 2 else view_name_info[2]
+            view_name_with_prefix, url = self._name_and_url(view_name_info)
             response = self.client.get(url)
-            self.assertEqual(response.status_code, 302, msg=f"{view_name_with_prefix} ({url}) accessible by non-staff")
+            self.assertEqual(response.status_code, expected_response_code,
+                             msg=f"{view_name_with_prefix} ({url}) accessible by non-staff")
 
+        # Logged in? Views should be visible
         self.client.force_login(self.staff_user)
-        for view_name in self.VIEWS_STAFF_ONLY:
-            view_name_with_prefix, url = self._name_and_url(view_name)
+        for view_name_info in self.VIEWS_STAFF_ONLY:
+            view_name_with_prefix, url = self._name_and_url(view_name_info)
             try:
                 response = self.client.get(url)
                 self.assertEqual(response.status_code, 200,
                                  msg=f"{view_name_with_prefix} ({url}) should be accessible for staff (but isn't)")
-            except Exception as e:
-                self.fail(f"An error occurred during rendering of {view_name_with_prefix} ({url}):\n\n{traceback.format_exc()}")
+            except Exception:  # pylint: disable=broad-exception-caught
+                self.fail(f"An error occurred during rendering of {view_name_with_prefix} ({url}):"
+                          f"\n\n{traceback.format_exc()}")
 
+        # Disabled user? Views should not be visible
         self.client.force_login(self.deactivated_user)
-        for view_name in self.VIEWS_STAFF_ONLY:
-            view_name_with_prefix, url = self._name_and_url(view_name)
+        for view_name_info in self.VIEWS_STAFF_ONLY:
+            expected_response_code = 302 if len(view_name_info) == 2 else view_name_info[2]
+            view_name_with_prefix, url = self._name_and_url(view_name_info)
             response = self.client.get(url)
-            self.assertEqual(response.status_code, 302,
+            self.assertEqual(response.status_code, expected_response_code,
                              msg=f"{view_name_with_prefix} ({url}) still accessible for deactivated user")
 
-    def _to_sendable_value(self, v):
+    def _to_sendable_value(self, val):
         """
         Create representation sendable via POST from form data
 
-        :param v: value to prepare
-        :type v: any
+        Needed to automatically check create, update and delete views
+
+        :param val: value to prepare
+        :type val: any
         :return: prepared value (normally either raw value or primary key of complex object)
         """
-        if type(v) == list:
-            return [e.pk for e in v]
-        if type(v) == "RelatedManager":
-            return [e.pk for e in v.all()]
-        return v
+        if isinstance(val, list):
+            return [e.pk for e in val]
+        if type(val) == "RelatedManager":  # pylint: disable=unidiomatic-typecheck
+            return [e.pk for e in val.all()]
+        return val
 
     def test_submit_edit_form(self):
         """
-        Test edit forms in the most simple way (sending them again unchanged)
+        Test edit forms (as specified in "EDIT_TESTCASES") in the most simple way (sending them again unchanged)
         """
         for testcase in self.EDIT_TESTCASES:
             self._test_submit_edit_form(testcase)
 
     def _test_submit_edit_form(self, testcase):
+        """
+        Test a single edit form by rendering and sending it again unchanged
+
+        This will test for correct rendering, dispatching/redirecting, messages and access control handling
+
+        :param testcase: details of the form to test
+        """
         name, url = self._name_and_url((testcase["view"], testcase["kwargs"]))
         form_name = testcase.get("form_name", "form")
         expected_code = testcase.get("expected_code", 302)
@@ -145,6 +197,9 @@ class BasicViewTests:
 
 
 class ModelViewTests(BasicViewTests, TestCase):
+    """
+    Basic view test cases for views from AKModel plus some custom tests
+    """
     fixtures = ['model.json']
 
     ADMIN_MODELS = [
@@ -172,35 +227,48 @@ class ModelViewTests(BasicViewTests, TestCase):
     ]
 
     def test_admin(self):
+        """
+        Test basic admin functionality (displaying and interacting with model instances)
+        """
         self.client.force_login(self.admin_user)
         for model in self.ADMIN_MODELS:
+            # Special treatment for a subset of views (where we exchanged default functionality, e.g., create views)
             if model[1] == "event":
-                view_name_with_prefix, url = self._name_and_url((f'admin:new_event_wizard_start', {}))
+                _, url = self._name_and_url(('admin:new_event_wizard_start', {}))
             elif model[1] == "room":
-                view_name_with_prefix, url = self._name_and_url((f'admin:room-new', {}))
+                _, url = self._name_and_url(('admin:room-new', {}))
+            # Otherwise, just call the creation form view
             else:
-                view_name_with_prefix, url = self._name_and_url((f'admin:AKModel_{model[1]}_add', {}))
+                _, url = self._name_and_url((f'admin:AKModel_{model[1]}_add', {}))
             response = self.client.get(url)
             self.assertEqual(response.status_code, 200, msg=f"Add form for model {model[1]} ({url}) broken")
 
         for model in self.ADMIN_MODELS:
+            # Test the update view using the first existing instance of each model
             m = model[0].objects.first()
             if m is not None:
-                view_name_with_prefix, url = self._name_and_url((f'admin:AKModel_{model[1]}_change', {'object_id': m.pk}))
+                _, url = self._name_and_url(
+                    (f'admin:AKModel_{model[1]}_change', {'object_id': m.pk})
+                )
                 response = self.client.get(url)
                 self.assertEqual(response.status_code, 200, msg=f"Edit form for model {model[1]} ({url}) broken")
 
     def test_wiki_export(self):
+        """
+        Test wiki export
+        This will test whether the view renders at all and whether the export list contains the correct AKs
+        """
         self.client.force_login(self.admin_user)
 
-        export_url = reverse_lazy(f"admin:ak_wiki_export", kwargs={'slug': 'kif42'})
+        export_url = reverse_lazy("admin:ak_wiki_export", kwargs={'slug': 'kif42'})
         response = self.client.get(export_url)
         self.assertEqual(response.status_code, 200, "Export not working at all")
 
         export_count = 0
-        for category, aks in response.context["categories_with_aks"]:
+        for _, aks in response.context["categories_with_aks"]:
             for ak in aks:
-                self.assertEqual(ak.include_in_export, True, f"AK with export flag set to False (pk={ak.pk}) included in export")
+                self.assertEqual(ak.include_in_export, True,
+                                 f"AK with export flag set to False (pk={ak.pk}) included in export")
                 self.assertNotEqual(ak.pk, 1, "AK known to be excluded from export (PK 1) included in export")
                 export_count += 1