update account holder in wiref file

.gitignore

@@ -19,3 +19,4 @@ flowbite
 gallery/*
 tailwind
 whoosh_index
+databases/django

Readme.md

@@ -136,6 +136,10 @@ ckeditor -> django-prose-editor
 
 ## Version History
 
+2.2.1
+
+* Fix rental (view, pdf file, sending mail)
+
 2.2.0
 
 * Add rental

docker-compose.yml

@@ -9,7 +9,7 @@ services:
     depends_on:
       - django-homepage
     volumes:
-      - files-volume:/usr/src/app/files
+      - ./files:/usr/src/app/files
       - ./gallery:/usr/src/app/files/uploads/gallery
       - ./assets:/usr/src/app/assets:ro
     networks:
@@ -24,8 +24,8 @@ services:
       SECRET_KEY: "sae34sADfrFr89E!Gl#f!34hdjGR#!jopi4qFEr#4R56rT56zT2#wE1!feGp"
       MYSQL_USER: "user"
       MYSQL_PASSWORD: "hgu"
-      ETHERPAD_GROUP: "g.snlbqn7S6ksRbom3"
-      EMAIL_HOST_USER: "verleih@fet.at"
+      ETHERPAD_GROUP: "g.snlbqn7S6ksRbom3"
+      EMAIL_HOST_USER: "verleih@fet.at"
       EMAIL_HOST_PASSWORD: ""
     depends_on:
       mysql:
@@ -47,7 +47,7 @@ services:
       retries: 20
   etherpad:
     container_name: etherpad-container
-    image: etherpad/etherpad:1.8.17
+    image: etherpad/etherpad:2.5.2
     # ports:
     #   - 9001:9001
     environment:
@@ -57,8 +57,9 @@ services:
       DB_NAME: etherpaddb
       DB_USER: user
       DB_PASS: "hgu"
-      DB_CHARSET: utf8
+      DB_CHARSET: "utf8mb4"
       TRUST_PROXY: false
+      AUTHENTICATION_METHOD: "apikey"
     depends_on:
       etherpadsql:
         condition: "service_healthy"
@@ -84,7 +85,8 @@ services:
       MYSQL_CHARSET: utf8
       MYSQL_ALLOW_EMPTY_PASSWORD: "yes"
     volumes:
-      - mysql-volume:/docker-entrypoint-initdb.d/
+      - ./inits/django:/docker-entrypoint-initdb.d/
+      - ./databases/django:/var/lib/mysql:Z
     networks:
       - django-db-network
     healthcheck:
@@ -102,7 +104,8 @@ services:
       MYSQL_CHARSET: utf8
       MYSQL_ALLOW_EMPTY_PASSWORD: "yes"
     volumes:
-      - etherpad-mysql-volume:/docker-entrypoint-initdb.d/
+      - ./init/etherpad:/docker-entrypoint-initdb.d/
+      - ./databases/etherpad:/var/lib/mysql:Z
     networks:
       - etherpad-db-network
     healthcheck:

fet2020/fet2020/__init__.py

@@ -1,6 +1,6 @@
 from django.utils.version import get_version
 
-VERSION = (2, 2, 0, "final", 0)
+VERSION = (2, 2, 1, "final", 0)
 BUILD = 0
 
 __version__ = get_version(VERSION)

fet2020/finance/admin.py

@@ -204,7 +204,12 @@ class BillAdmin(admin.ModelAdmin):
     actions = ["make_cleared", "make_finished"]
     autocomplete_fields = ["resolution"]
     list_filter = ["status", "affiliation", "payer", BillPeriodeFilter]
-    search_fields = ["purpose", "bankdata__name"]
+    search_fields = [
+        "purpose",
+        "bankdata__name",
+        "bill_creator__firstname",
+        "bill_creator__surname",
+    ]
     show_facets = admin.ShowFacets.ALWAYS
     ordering = ["-id"]
 

fet2020/finance/forms.py

@@ -6,6 +6,7 @@ from django import forms
 from django.core.validators import ValidationError
 from django.db.models import Count, Q
 from django.forms import DateInput
+from django.utils import timezone
 
 from members.models import Member
 
@@ -412,7 +413,7 @@ class BillAdminForm(forms.ModelForm):
         self.fields["resolution"].queryset = self.fields["resolution"].queryset.filter(
             (
                 Q(option=Resolution.Option.FINANCE)
-                & Q(date__gt=datetime.datetime.now(tz=datetime.UTC).date() - relativedelta(years=2))
+                & Q(date__gt=timezone.now().date() - relativedelta(years=2))
             )
             | Q(option=Resolution.Option.PERMANENT)
         )

fet2020/finance/utils.py

@@ -1,8 +1,8 @@
-import datetime
 import io
 from pathlib import Path
 
 from django.core.files import File
+from django.utils import timezone
 from pypdf import PdfReader, PdfWriter
 from pypdf.constants import FieldDictionaryAttributes as FA  # noqa: N814
 
@@ -34,7 +34,7 @@ def generate_pdf(wiref):
         )
 
     # Get budget year
-    today = datetime.datetime.now(tz=datetime.UTC).date()
+    today = timezone.now().date()
     if today.month < 7:
         budget_year = f"{today.year - 1}-{today.year}"
     else:

fet2020/posts/forms.py

@@ -1,275 +1,275 @@
-from ckeditor_uploader.widgets import CKEditorUploadingWidget
-from django import forms
-from django.forms.widgets import CheckboxInput
-from django.utils.dates import MONTHS
-from taggit.models import Tag
-
-from .models import Event, FetMeeting, News, Post
-
-
-class PostForm(forms.ModelForm):
-    class Meta:
-        model = Post
-        fields = [
-            "title",
-            "subtitle",
-            "tags",
-            "image",
-            "body",
-            "slug",
-            "author",
-            "public_date",
-        ]
-
-        widgets = {"body": CKEditorUploadingWidget(config_name="default")}
-
-    class Media:
-        js = (
-            "js/auto_slug.js",  # automatic slag completion via ajax
-            "js/tag_completion.js",  # to get a list for tag autocompletion via ajax
-        )
-
-
-class NewsForm(PostForm):
-    class Meta:
-        model = News
-        fields = "__all__"
-
-        help_texts = {
-            "tags": (
-                "Die Hashtags ohne '#' eintragen, und mit Komma kann man mehrere Tags anfügen."
-            ),
-            "image": "Verwendbare Formate: ...",
-            "is_pinned": (
-                "Der Post soll als erster auf der Startseite angeheftet werden und sich "
-                "automatisch einen Monat nach der Veröffentlichung wieder lösen."
-            ),
-        }
-
-        labels = {
-            "title": "Titel",
-            "subtitle": "Untertitel",
-            "image": "Hintergrundbild",
-            "body": "Text",
-            "slug": "Permalink",
-            "author": "Autor",
-            "public_date": "Veröffentlichung",
-            "is_pinned": "Post anheften",
-        }
-
-        widgets = {"body": CKEditorUploadingWidget(config_name="default")}
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)  # to get the self.fields set
-        author_qs = self.fields["author"].queryset.order_by("username")
-        self.fields["author"].queryset = author_qs
-
-
-class EventForm(PostForm):
-    class Meta:
-        model = Event
-        fields = "__all__"
-
-        help_texts = {
-            "tags": (
-                "Die Hashtags ohne '#' eintragen, und mit Komma kann man mehrere Tags anfügen."
-            ),
-            "image": "Verwendbare Formate: Bildformate",
-            "is_pinned": (
-                "Dieses Event soll als erstes auf der Startseite angeheftet werden und sich "
-                "automatisch einen Monat nach der Veröffentlichung wieder lösen."
-            ),
-        }
-
-        labels = {
-            "title": "Titel",
-            "subtitle": "Untertitel",
-            "image": "Hintergrundbild",
-            "body": "Text",
-            "event_start": "Start des Events",
-            "event_end": "Ende des Events",
-            "event_place": "Ort des Events",
-            "slug": "Permalink",
-            "author": "Autor",
-            "public_date": "Veröffentlichung",
-            "is_pinned": "Event anheften",
-        }
-
-        widgets = {"body": CKEditorUploadingWidget(config_name="default")}
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)  # to get the self.fields set
-        author_qs = self.fields["author"].queryset.order_by("username")
-        self.fields["author"].queryset = author_qs
-
-        self.fields["event_start"].required = True
-        self.fields["event_end"].required = False
-
-        if "event_place" in self.fields:
-            self.fields["event_place"].required = True
-
-
-class FetMeetingForm(PostForm):
-    class Meta:
-        model = FetMeeting
-        fields = ["event_start", "event_end", "event_place", "tags"]
-
-        labels = {
-            "event_start": "Start der Sitzung",
-            "event_end": "Ende der Sitzung",
-            "event_place": "Ort der Sitzung",
-        }
-
-        help_texts = {
-            "event_end": "Bei einer leeren Eingabe werden 2 Stunden zur Startzeit dazugezählt.",
-            "tags": (
-                "Die Hashtags ohne '#' eintragen, und mit Komma kann man mehrere Tags anfügen."
-            ),
-        }
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)  # to get the self.fields set
-
-        self.fields["event_start"].required = True
-        self.fields["event_end"].required = False
-
-        self.fields["event_place"].initial = "FET"
-
-        tags = []
-        tags.append(Tag())
-        tags[0].name = "fachschaft"
-        self.fields["tags"].initial = tags
-
-
-class PostSearchForm(forms.Form):
-    year_choices = [("", "Alle")]
-    month_choices = [("", "Alle")] + list(MONTHS.items())
-
-    year = forms.ChoiceField(label="Jahr", choices=year_choices, required=False)
-    month = forms.ChoiceField(label="Monat", choices=month_choices, required=False)
-
-    compact_view = forms.BooleanField(
-        label="Kompakte Ansicht",
-        required=False,
-        widget=CheckboxInput,
-    )
-    fet_meeting_only = forms.BooleanField(
-        label="nur FET Sitzungen",
-        required=False,
-        widget=CheckboxInput,
-    )
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)  # to get the self.fields set
-
-        try:
-            first_post = Post.objects.get_queryset().last()
-            last_post = Post.objects.get_queryset().first()
-            if first_post and last_post:
-                years = range(last_post.date.year, first_post.date.year - 1, -1)
-                year_choices = [("", "Alle")] + [(i, i) for i in years]
-                self.fields["year"].choices = year_choices
-        except Exception:
-            pass
-
-
-class NewsUpdateForm(forms.ModelForm):
-    class Meta:
-        model = News
-
-        fields = [
-            "title",
-            "status",
-            "body",
-        ]
-
-        labels = {
-            "title": "Titel",
-            "image": "Hintergrundbild",
-            "body": "Text",
-        }
-
-        widgets = {"body": CKEditorUploadingWidget(config_name="default")}
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)  # to get the self.fields set
-
-        self.fields["title"].autofocus = True
-
-
-class EventUpdateForm(forms.ModelForm):
-    class Meta:
-        model = Event
-        fields = [
-            "title",
-            "status",
-            "event_start",
-            "event_end",
-            "event_place",
-        ]
-
-        labels = {
-            "title": "Titel",
-            "event_start": "Start des Events",
-            "event_end": "Ende des Events",
-            "event_place": "Ort des Events",
-        }
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)  # to get the self.fields set
-
-        self.fields["event_start"].required = True
-        self.fields["event_start"].autofocus = True
-
-        self.fields["event_end"].required = False
-
-        if "event_place" in self.fields:
-            self.fields["event_place"].required = True
-
-
-class FetMeetingCreateForm(forms.ModelForm):
-    class Meta:
-        model = FetMeeting
-        fields = ["event_start", "event_end", "event_place"]
-
-        help_texts = {
-            "event_end": "Bei einer leeren Eingabe werden 2 Stunden zur Startzeit dazugezählt.",
-        }
-
-        labels = {
-            "event_start": "Start der Sitzung",
-            "event_end": "Ende der Sitzung",
-            "event_place": "Ort der Sitzung",
-        }
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)  # to get the self.fields set
-
-        self.fields["event_start"].required = True
-        self.fields["event_start"].autofocus = True
-
-        self.fields["event_end"].required = False
-
-        self.fields["event_place"].initial = "FET"
-
-
-class FetMeetingUpdateForm(forms.ModelForm):
-    class Meta:
-        model = FetMeeting
-        fields = ["event_start", "event_end", "event_place"]
-
-        labels = {
-            "event_start": "Start der Sitzung",
-            "event_end": "Ende der Sitzung",
-            "event_place": "Ort der Sitzung",
-        }
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)  # to get the self.fields set
-
-        self.fields["event_start"].required = True
-        self.fields["event_start"].autofocus = True
-
-        self.fields["event_end"].required = False
-
-        self.fields["event_place"].initial = "FET"
+from ckeditor_uploader.widgets import CKEditorUploadingWidget
+from django import forms
+from django.forms.widgets import CheckboxInput
+from django.utils.dates import MONTHS
+from taggit.models import Tag
+
+from .models import Event, FetMeeting, News, Post
+
+
+class PostForm(forms.ModelForm):
+    class Meta:
+        model = Post
+        fields = [
+            "title",
+            "subtitle",
+            "tags",
+            "image",
+            "body",
+            "slug",
+            "author",
+            "public_date",
+        ]
+
+        widgets = {"body": CKEditorUploadingWidget(config_name="default")}
+
+    class Media:
+        js = (
+            "js/auto_slug.js",  # automatic slag completion via ajax
+            "js/tag_completion.js",  # to get a list for tag autocompletion via ajax
+        )
+
+
+class NewsForm(PostForm):
+    class Meta:
+        model = News
+        fields = "__all__"
+
+        help_texts = {
+            "tags": (
+                "Die Hashtags ohne '#' eintragen, und mit Komma kann man mehrere Tags anfügen."
+            ),
+            "image": "Verwendbare Formate: ...",
+            "is_pinned": (
+                "Der Post soll als erster auf der Startseite angeheftet werden und sich "
+                "automatisch einen Monat nach der Veröffentlichung wieder lösen."
+            ),
+        }
+
+        labels = {
+            "title": "Titel",
+            "subtitle": "Untertitel",
+            "image": "Hintergrundbild",
+            "body": "Text",
+            "slug": "Permalink",
+            "author": "Autor",
+            "public_date": "Veröffentlichung",
+            "is_pinned": "Post anheften",
+        }
+
+        widgets = {"body": CKEditorUploadingWidget(config_name="default")}
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)  # to get the self.fields set
+        author_qs = self.fields["author"].queryset.order_by("username")
+        self.fields["author"].queryset = author_qs
+
+
+class EventForm(PostForm):
+    class Meta:
+        model = Event
+        fields = "__all__"
+
+        help_texts = {
+            "tags": (
+                "Die Hashtags ohne '#' eintragen, und mit Komma kann man mehrere Tags anfügen."
+            ),
+            "image": "Verwendbare Formate: Bildformate",
+            "is_pinned": (
+                "Dieses Event soll als erstes auf der Startseite angeheftet werden und sich "
+                "automatisch ein Tag nach dem Eventende wieder lösen."
+            ),
+        }
+
+        labels = {
+            "title": "Titel",
+            "subtitle": "Untertitel",
+            "image": "Hintergrundbild",
+            "body": "Text",
+            "event_start": "Start des Events",
+            "event_end": "Ende des Events",
+            "event_place": "Ort des Events",
+            "slug": "Permalink",
+            "author": "Autor",
+            "public_date": "Veröffentlichung",
+            "is_pinned": "Event anheften",
+        }
+
+        widgets = {"body": CKEditorUploadingWidget(config_name="default")}
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)  # to get the self.fields set
+        author_qs = self.fields["author"].queryset.order_by("username")
+        self.fields["author"].queryset = author_qs
+
+        self.fields["event_start"].required = True
+        self.fields["event_end"].required = False
+
+        if "event_place" in self.fields:
+            self.fields["event_place"].required = True
+
+
+class FetMeetingForm(PostForm):
+    class Meta:
+        model = FetMeeting
+        fields = ["event_start", "event_end", "event_place", "tags"]
+
+        labels = {
+            "event_start": "Start der Sitzung",
+            "event_end": "Ende der Sitzung",
+            "event_place": "Ort der Sitzung",
+        }
+
+        help_texts = {
+            "event_end": "Bei einer leeren Eingabe werden 2 Stunden zur Startzeit dazugezählt.",
+            "tags": (
+                "Die Hashtags ohne '#' eintragen, und mit Komma kann man mehrere Tags anfügen."
+            ),
+        }
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)  # to get the self.fields set
+
+        self.fields["event_start"].required = True
+        self.fields["event_end"].required = False
+
+        self.fields["event_place"].initial = "FET"
+
+        tags = []
+        tags.append(Tag())
+        tags[0].name = "fachschaft"
+        self.fields["tags"].initial = tags
+
+
+class PostSearchForm(forms.Form):
+    year_choices = [("", "Alle")]
+    month_choices = [("", "Alle")] + list(MONTHS.items())
+
+    year = forms.ChoiceField(label="Jahr", choices=year_choices, required=False)
+    month = forms.ChoiceField(label="Monat", choices=month_choices, required=False)
+
+    compact_view = forms.BooleanField(
+        label="Kompakte Ansicht",
+        required=False,
+        widget=CheckboxInput,
+    )
+    fet_meeting_only = forms.BooleanField(
+        label="nur FET Sitzungen",
+        required=False,
+        widget=CheckboxInput,
+    )
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)  # to get the self.fields set
+
+        try:
+            first_post = Post.objects.get_queryset().last()
+            last_post = Post.objects.get_queryset().first()
+            if first_post and last_post:
+                years = range(last_post.date.year, first_post.date.year - 1, -1)
+                year_choices = [("", "Alle")] + [(i, i) for i in years]
+                self.fields["year"].choices = year_choices
+        except Exception:
+            pass
+
+
+class NewsUpdateForm(forms.ModelForm):
+    class Meta:
+        model = News
+
+        fields = [
+            "title",
+            "status",
+            "body",
+        ]
+
+        labels = {
+            "title": "Titel",
+            "image": "Hintergrundbild",
+            "body": "Text",
+        }
+
+        widgets = {"body": CKEditorUploadingWidget(config_name="default")}
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)  # to get the self.fields set
+
+        self.fields["title"].autofocus = True
+
+
+class EventUpdateForm(forms.ModelForm):
+    class Meta:
+        model = Event
+        fields = [
+            "title",
+            "status",
+            "event_start",
+            "event_end",
+            "event_place",
+        ]
+
+        labels = {
+            "title": "Titel",
+            "event_start": "Start des Events",
+            "event_end": "Ende des Events",
+            "event_place": "Ort des Events",
+        }
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)  # to get the self.fields set
+
+        self.fields["event_start"].required = True
+        self.fields["event_start"].autofocus = True
+
+        self.fields["event_end"].required = False
+
+        if "event_place" in self.fields:
+            self.fields["event_place"].required = True
+
+
+class FetMeetingCreateForm(forms.ModelForm):
+    class Meta:
+        model = FetMeeting
+        fields = ["event_start", "event_end", "event_place"]
+
+        help_texts = {
+            "event_end": "Bei einer leeren Eingabe werden 2 Stunden zur Startzeit dazugezählt.",
+        }
+
+        labels = {
+            "event_start": "Start der Sitzung",
+            "event_end": "Ende der Sitzung",
+            "event_place": "Ort der Sitzung",
+        }
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)  # to get the self.fields set
+
+        self.fields["event_start"].required = True
+        self.fields["event_start"].autofocus = True
+
+        self.fields["event_end"].required = False
+
+        self.fields["event_place"].initial = "FET"
+
+
+class FetMeetingUpdateForm(forms.ModelForm):
+    class Meta:
+        model = FetMeeting
+        fields = ["event_start", "event_end", "event_place"]
+
+        labels = {
+            "event_start": "Start der Sitzung",
+            "event_end": "Ende der Sitzung",
+            "event_place": "Ort der Sitzung",
+        }
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)  # to get the self.fields set
+
+        self.fields["event_start"].required = True
+        self.fields["event_start"].autofocus = True
+
+        self.fields["event_end"].required = False
+
+        self.fields["event_place"].initial = "FET"

fet2020/posts/managers.py

@@ -1,201 +1,208 @@
-import datetime
-
-from django.db import models
-from django.db.models import Case, Q, When
-
-from .choices import PostType, Status
-
-
-class PublishedManager(models.Manager):
-    def published(self, public=True):
-        """
-        publish all posts with status 'PUBLIC'
-        """
-        return self.get_queryset().filter(status=Status.PUBLIC) if public else self.get_queryset()
-
-    def published_all(self, public=True):
-        """
-        publish all posts with status 'PUBLIC' and 'ONLY_INTERN'
-        """
-        return (
-            self.get_queryset().filter(~Q(status=Status.DRAFT)) if public else self.get_queryset()
-        )
-
-
-class PostManager(PublishedManager, models.Manager):
-    def get_queryset(self):
-        qs = (
-            super()
-            .get_queryset()
-            .annotate(
-                date=Case(
-                    When(post_type=PostType.NEWS, then="public_date"),
-                    When(post_type=PostType.EVENT, then="event_start__date"),
-                    When(post_type=PostType.FETMEETING, then="event_start__date"),
-                ),
-            )
-        )
-        return qs.order_by("-date", "-id")
-
-    def date_sorted(self, public=True):
-        return self.published(public)
-
-    def date_filter(
-        self,
-        public=True,
-        year=None,
-        month=None,
-        fet_meeting_only=None,
-    ):
-        qs_filter = Q()
-
-        if fet_meeting_only:
-            qs_filter &= Q(post_type=PostType.FETMEETING)
-
-        if year:
-            qs_filter &= Q(date__year=year)
-            if month:
-                qs_filter &= Q(date__month=month)
-
-        return self.published(public).filter(qs_filter)
-
-
-class ArticleManager(PublishedManager, models.Manager):
-    """
-    Provide a query set only for "Article"
-    regular fet meetings should not be contained in the news stream
-    """
-
-    def get_queryset(self):
-        qs = super().get_queryset().filter(Q(post_type=PostType.NEWS) | Q(post_type=PostType.EVENT))
-        qs = qs.annotate(
-            date=Case(
-                When(post_type=PostType.NEWS, then="public_date"),
-                When(post_type=PostType.EVENT, then="event_start__date"),
-            ),
-        )
-        return qs.order_by("-date", "-id")
-
-    def date_sorted(self, public=True):
-        return self.published(public)
-
-    def pinned(self, public=True):
-        # Get date for pinned news that is max 1 month old.
-        post_date = datetime.datetime.now(tz=datetime.UTC).date()
-        __month = post_date.month
-        __year = post_date.year
-
-        if __month != 1:
-            __month -= 1
-        else:
-            # If the current month is January, you get the date from December of previous year.
-            __month = 12
-            __year -= 1
-
-        post_date = post_date.replace(year=__year, month=__month)
-
-        # Get date for event posts that is max 1 day old.
-        event_date = datetime.datetime.now(tz=datetime.UTC).date() - datetime.timedelta(1)
-
-        return (
-            self.published(public)
-            .filter(
-                Q(is_pinned=True)
-                & (
-                    (Q(post_type=PostType.NEWS) & Q(public_date__gt=post_date))
-                    | (Q(post_type=PostType.EVENT) & Q(event_end__date__gt=event_date))
-                )
-            )
-            .first()
-        )
-
-
-class NewsManager(PublishedManager, models.Manager):
-    """
-    Provide a query set only for "News"
-    """
-
-    def get_queryset(self):
-        qs = super().get_queryset().filter(post_type=PostType.NEWS)
-        qs = qs.annotate(
-            date=Case(
-                When(post_type=PostType.NEWS, then="public_date"),
-            ),
-        )
-        return qs.order_by("-date")
-
-
-class AllEventManager(PublishedManager, models.Manager):
-    """
-    Provide a query set for all events ("Event" and "Fet Meeting")
-    """
-
-    def get_queryset(self):
-        qs = (
-            super()
-            .get_queryset()
-            .filter(Q(post_type=PostType.EVENT) | Q(post_type=PostType.FETMEETING))
-        )
-        qs = qs.annotate(
-            date=Case(
-                When(post_type=PostType.EVENT, then="event_start__date"),
-                When(post_type=PostType.FETMEETING, then="event_start__date"),
-            ),
-        )
-        return qs.order_by("-date")
-
-    def future_events(self, public=True):
-        date_today = datetime.datetime.now(tz=datetime.UTC).date()
-        qs = self.published(public).filter(event_start__gt=date_today)
-        return qs.reverse()
-
-
-class EventManager(PublishedManager, models.Manager):
-    """
-    Provide a query set only for "Events"
-    regular fet meetings should not be contained in the news stream
-    """
-
-    def get_queryset(self):
-        qs = super().get_queryset().filter(post_type=PostType.EVENT)
-        qs = qs.annotate(
-            date=Case(
-                When(post_type=PostType.EVENT, then="event_start__date"),
-            ),
-        )
-        return qs.order_by("-date")
-
-    def future_events(self, public=True):
-        date_today = datetime.datetime.now(tz=datetime.UTC).date()
-        qs = self.published(public).filter(event_start__gt=date_today)
-        return qs.reverse()
-
-    def past_events(self, public=True):
-        date_today = datetime.datetime.now(tz=datetime.UTC).date()
-        qs = self.published(public).filter(event_start__lt=date_today)
-        return qs
-
-
-class FetMeetingManager(PublishedManager, models.Manager):
-    """
-    Provide a query set only for "Fet Meeting"
-    """
-
-    def get_queryset(self):
-        qs = super().get_queryset().filter(post_type=PostType.FETMEETING)
-        qs = qs.annotate(
-            date=Case(
-                When(post_type=PostType.FETMEETING, then="event_start__date"),
-            ),
-        )
-        return qs.order_by("-date")
-
-    def future_events(self):
-        date_today = datetime.datetime.now(tz=datetime.UTC).date()
-        qs = self.published().filter(event_start__gt=date_today)
-        return qs.reverse()
-
-    def past_events(self):
-        date_today = datetime.datetime.now(tz=datetime.UTC).date()
-        qs = self.published().filter(event_start__lt=date_today)
-        return qs
+import calendar
+import datetime
+
+from django.db import models
+from django.db.models import Case, Q, When
+from django.utils import timezone
+
+from .choices import PostType, Status
+
+
+class PublishedManager(models.Manager):
+    def published(self, public=True):
+        """
+        publish all posts with status 'PUBLIC'
+        """
+        return self.get_queryset().filter(status=Status.PUBLIC) if public else self.get_queryset()
+
+    def published_all(self, public=True):
+        """
+        publish all posts with status 'PUBLIC' and 'ONLY_INTERN'
+        """
+        return (
+            self.get_queryset().filter(~Q(status=Status.DRAFT)) if public else self.get_queryset()
+        )
+
+
+class PostManager(PublishedManager, models.Manager):
+    def get_queryset(self):
+        qs = (
+            super()
+            .get_queryset()
+            .annotate(
+                date=Case(
+                    When(post_type=PostType.NEWS, then="public_date"),
+                    When(post_type=PostType.EVENT, then="event_start__date"),
+                    When(post_type=PostType.FETMEETING, then="event_start__date"),
+                ),
+            )
+        )
+        return qs.order_by("-date", "-id")
+
+    def date_sorted(self, public=True):
+        return self.published(public)
+
+    def date_filter(
+        self,
+        public=True,
+        year=None,
+        month=None,
+        fet_meeting_only=None,
+    ):
+        qs_filter = Q()
+
+        if fet_meeting_only:
+            qs_filter &= Q(post_type=PostType.FETMEETING)
+
+        if year:
+            qs_filter &= Q(date__year=year)
+            if month:
+                qs_filter &= Q(date__month=month)
+
+        return self.published(public).filter(qs_filter)
+
+
+class ArticleManager(PublishedManager, models.Manager):
+    """
+    Provide a query set only for "Article"
+    regular fet meetings should not be contained in the news stream
+    """
+
+    def get_queryset(self):
+        qs = super().get_queryset().filter(Q(post_type=PostType.NEWS) | Q(post_type=PostType.EVENT))
+        qs = qs.annotate(
+            date=Case(
+                When(post_type=PostType.NEWS, then="public_date"),
+                When(post_type=PostType.EVENT, then="event_start__date"),
+            ),
+        )
+        return qs.order_by("-date", "-id")
+
+    def date_sorted(self, public=True):
+        return self.published(public)
+
+    def pinned(self, public=True):
+        # Get date for pinned news that is max 1 month old.
+        post_date = timezone.now().date()
+        _day = post_date.day
+        _month = post_date.month
+        _year = post_date.year
+
+        if _month != 1:
+            _month -= 1
+        else:
+            # If the current month is January, you get the date from December of previous year.
+            _month = 12
+            _year -= 1
+
+        # Clamp day to last day of target month (handles 30/31 and Feb)
+        last_day = calendar.monthrange(_year, _month)[1]
+        safe_day = min(_day, last_day)
+
+        post_date = post_date.replace(year=_year, month=_month, day=safe_day)
+
+        # Get date for event posts that is max 1 day old.
+        event_date = timezone.now().date() - datetime.timedelta(1)
+
+        return (
+            self.published(public)
+            .filter(
+                Q(is_pinned=True)
+                & (
+                    (Q(post_type=PostType.NEWS) & Q(public_date__gt=post_date))
+                    | (Q(post_type=PostType.EVENT) & Q(event_end__date__gt=event_date))
+                )
+            )
+            .first()
+        )
+
+
+class NewsManager(PublishedManager, models.Manager):
+    """
+    Provide a query set only for "News"
+    """
+
+    def get_queryset(self):
+        qs = super().get_queryset().filter(post_type=PostType.NEWS)
+        qs = qs.annotate(
+            date=Case(
+                When(post_type=PostType.NEWS, then="public_date"),
+            ),
+        )
+        return qs.order_by("-date")
+
+
+class AllEventManager(PublishedManager, models.Manager):
+    """
+    Provide a query set for all events ("Event" and "Fet Meeting")
+    """
+
+    def get_queryset(self):
+        qs = (
+            super()
+            .get_queryset()
+            .filter(Q(post_type=PostType.EVENT) | Q(post_type=PostType.FETMEETING))
+        )
+        qs = qs.annotate(
+            date=Case(
+                When(post_type=PostType.EVENT, then="event_start__date"),
+                When(post_type=PostType.FETMEETING, then="event_start__date"),
+            ),
+        )
+        return qs.order_by("-date")
+
+    def future_events(self, public=True):
+        date_today = timezone.now().date()
+        qs = self.published(public).filter(event_start__gt=date_today)
+        return qs.reverse()
+
+
+class EventManager(PublishedManager, models.Manager):
+    """
+    Provide a query set only for "Events"
+    regular fet meetings should not be contained in the news stream
+    """
+
+    def get_queryset(self):
+        qs = super().get_queryset().filter(post_type=PostType.EVENT)
+        qs = qs.annotate(
+            date=Case(
+                When(post_type=PostType.EVENT, then="event_start__date"),
+            ),
+        )
+        return qs.order_by("-date")
+
+    def future_events(self, public=True):
+        date_today = timezone.now().date()
+        qs = self.published(public).filter(event_start__gt=date_today)
+        return qs.reverse()
+
+    def past_events(self, public=True):
+        date_today = timezone.now().date()
+        qs = self.published(public).filter(event_start__lt=date_today)
+        return qs
+
+
+class FetMeetingManager(PublishedManager, models.Manager):
+    """
+    Provide a query set only for "Fet Meeting"
+    """
+
+    def get_queryset(self):
+        qs = super().get_queryset().filter(post_type=PostType.FETMEETING)
+        qs = qs.annotate(
+            date=Case(
+                When(post_type=PostType.FETMEETING, then="event_start__date"),
+            ),
+        )
+        return qs.order_by("-date")
+
+    def future_events(self):
+        date_today = timezone.now().date()
+        qs = self.published().filter(event_start__gt=date_today)
+        return qs.reverse()
+
+    def past_events(self):
+        date_today = timezone.now().date()
+        qs = self.published().filter(event_start__lt=date_today)
+        return qs

fet2020/rental/forms.py

@@ -1,58 +1,65 @@
-from django import forms
-from django.forms import DateInput
-
-from .models import Rental, RentalItem
-
-
-class DateInput(DateInput):
-    input_type = "date"
-
-
-class RentalCreateForm(forms.ModelForm):
-    # Conformation
-    conformation = forms.BooleanField(
-        required=True,
-        label=("Ich habe die Verleihregeln gelesen und akzeptiere sie."),
-        initial=False,
-    )
-
-    class Meta:
-        model = Rental
-
-        fields = [
-            "firstname",
-            "surname",
-            "matriculation_number",
-            "email",
-            "phone",
-            "organization",
-            "date_start",
-            "date_end",
-            "reason",
-            "comment",
-            "rentalitems",
-        ]
-
-        widgets = {
-            "date_start": DateInput(format=("%Y-%m-%d")),
-            "date_end": DateInput(format=("%Y-%m-%d")),
-        }
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)  # to get the self.fields set
-
-        self.fields["firstname"].autofocus = True
-
-
-class RentalAdminForm(forms.ModelForm):
-    class Meta:
-        model = Rental
-        fields = "__all__"
-
-        widgets = {"rentalitems": forms.CheckboxSelectMultiple()}
-
-
-class RentalItemAdminForm(forms.ModelForm):
-    class Meta:
-        model = RentalItem
-        fields = "__all__"
+from django import forms
+from django.forms import DateInput
+
+from .models import Rental, RentalItem
+
+
+class DateInput(DateInput):
+    input_type = "date"
+
+
+class RentalCreateForm(forms.ModelForm):
+    # Conformation
+    conformation = forms.BooleanField(
+        required=True,
+        label=("Ich habe die Verleihregeln gelesen und akzeptiere sie."),
+        initial=False,
+    )
+
+    class Meta:
+        model = Rental
+
+        fields = [
+            "firstname",
+            "surname",
+            "matriculation_number",
+            "email",
+            "phone",
+            "organization",
+            "date_start",
+            "date_end",
+            "reason",
+            "comment",
+            "rentalitems",
+        ]
+
+        widgets = {
+            "date_start": DateInput(format=("%Y-%m-%d")),
+            "date_end": DateInput(format=("%Y-%m-%d")),
+        }
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)  # to get the self.fields set
+
+        self.fields["firstname"].autofocus = True
+
+
+class RentalAdminForm(forms.ModelForm):
+    class Meta:
+        model = Rental
+        fields = "__all__"
+
+        widgets = {"rentalitems": forms.CheckboxSelectMultiple()}
+
+        help_texts = {
+            "status": (
+                "Wird der Status auf 'Verleih genehmigt' oder 'Verleih abgelehnt' gesetzt, wird "
+                "eine E-Mail gesendet."
+            ),
+        }
+
+
+class RentalItemAdminForm(forms.ModelForm):
+    class Meta:
+        model = RentalItem
+        fields = "__all__"

fet2020/rental/migrations/0002_rental_intern.py

@@ -0,0 +1,18 @@
+# Generated by Django 5.2.7 on 2025-10-30 14:40
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('rental', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='rental',
+            name='intern',
+            field=models.BooleanField(default=False, verbose_name='Interner Verleih'),
+        ),
+    ]

fet2020/rental/views.py

@@ -6,6 +6,7 @@ from django.db.models import Q
 from django.http import HttpResponseRedirect
 from django.shortcuts import render
 from django.urls import reverse
+from django.utils import timezone
 from django.views.generic import ListView, TemplateView
 from django.views.generic.detail import DetailView
 from django.views.generic.edit import CreateView
@@ -64,7 +65,7 @@ def _get_display_period(view_type: str, period: str) -> date:
             )
         except Exception:
             # Get first day of the current week
-            today = datetime.datetime.now(tz=datetime.UTC).date()
+            today = timezone.now().date()
             display_date = today - datetime.timedelta(days=today.weekday())
 
     # Handle month view
@@ -76,7 +77,7 @@ def _get_display_period(view_type: str, period: str) -> date:
             )
         except Exception:
             # Get the first day of the current month
-            display_date = datetime.datetime.now(tz=datetime.UTC).date().replace(day=1)
+            display_date = timezone.now().date().replace(day=1)
 
     return display_date
 
@@ -170,7 +171,7 @@ class RentalListView(ListView):
             context["week_num"] = week_num
 
         # Get the current date for the calendar
-        context["today"] = datetime.datetime.now(tz=datetime.UTC).date()
+        context["today"] = timezone.now().date()
 
         # Add rental items to the context for the filter
         context["rentalitems"] = RentalItem.objects.all()
@@ -234,7 +235,7 @@ class RentalCreateView(CreateView):
         selected_items = sorted(items, key=lambda x: x.name.lower())
 
         for i in range(0, len(selected_items), RENTAL_ITEMS_MAX):
-            batch = selected_items[i:i + RENTAL_ITEMS_MAX]
+            batch = selected_items[i : i + RENTAL_ITEMS_MAX]
 
             # Clone base_rental — copying all its field values
             new_rental = Rental.objects.create(
@@ -266,6 +267,7 @@ class RentalCreateView(CreateView):
     def get_success_url(self):
         return reverse("rental:rental_create_done")
 
+
 class RentalCreateDoneView(TemplateView):
     template_name = "rental/create_done.html"