update account holder in wiref file

.gitignore

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

Readme.md

@@ -96,6 +96,8 @@ docker build -t django-nginx-image -f nginx/Dockerfile ./nginx
 
 ### Start docker container
 
+Add email password for 'Verleih' account to EMAIL_HOST_PASSWORD in the docker compose file!
+
 Build the docker containers:
 
 ```bash
@@ -134,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:
@@ -25,6 +25,8 @@ services:
       MYSQL_USER: "user"
       MYSQL_PASSWORD: "hgu"
       ETHERPAD_GROUP: "g.snlbqn7S6ksRbom3"
+      EMAIL_HOST_USER: "verleih@fet.at"
+      EMAIL_HOST_PASSWORD: ""
     depends_on:
       mysql:
         condition: service_healthy
@@ -45,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:
@@ -55,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"
@@ -82,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:
@@ -100,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/fet2020/settings.py

@@ -18,6 +18,8 @@ env = environ.Env(
     ETHERPAD_GROUP=(str, ""),
     GALLERY_PATH=(str, "uploads/gallery"),
     MC_MASTERPASSWORD=(str, ""),
+    EMAIL_HOST_USER=(str, ""),
+    EMAIL_HOST_PASSWORD=(str, ""),
 )
 
 # Build paths inside the project like this: os.path.join(BASE_DIR, ...)
@@ -103,6 +105,8 @@ else:
 EMAIL_BACKEND = "django.core.mail.backends.smtp.EmailBackend"
 EMAIL_HOST = "buran.htu.tuwien.ac.at"
 EMAIL_PORT = 587
+EMAIL_HOST_USER = env("EMAIL_HOST_USER")
+EMAIL_HOST_PASSWORD = env("EMAIL_HOST_PASSWORD")
 EMAIL_USE_TLS = True
 
 

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/admin.py

@@ -1,124 +1,121 @@
-from django.contrib import admin, messages
-from django.http import HttpResponseRedirect
-
-from .forms import RentalAdminForm, RentalItemAdminForm
-from .models import Rental, RentalItem
-from .utils import generate_rental_pdf
-
-
-@admin.register(Rental)
-class RentalAdmin(admin.ModelAdmin):
-    form = RentalAdminForm
-    model = Rental
-
-    list_display = [
-        "id",
-        "firstname",
-        "surname",
-        "status",
-        "total_disposit",
-        "date_start",
-        "date_end",
-    ]
-    ordering = ["-id"]
-
-    readonly_fields = ["total_disposit"]
-
-    fieldsets = (
-        (
-            "Persönliche Daten",
-            {
-                "fields": (
-                    ("firstname", "surname"),
-                    ("organization", "matriculation_number"),
-                    ("email", "phone"),
-                ),
-            },
-        ),
-        (
-            "Verleih",
-            {
-                "fields": (
-                    ("date_start", "date_end"),
-                    "reason",
-                    "rentalitems",
-                    "total_disposit",
-                ),
-            },
-        ),
-        (
-            "Sonstiges",
-            {
-                "fields": (
-                    "comment",
-                    "file_field",
-                    "status",
-                ),
-            },
-        ),
-    )
-
-    def add_view(self, request, form_url="", extra_context=None):
-        extra_context = extra_context or {}
-        extra_context["help_text"] = "Fette Schriften sind Pflichtfelder."
-        return super().add_view(request, form_url, extra_context=extra_context)
-
-    def change_view(self, request, object_id, form_url="", extra_context=None):
-        extra_context = extra_context or {}
-        extra_context["help_text"] = "Fette Schriften sind Pflichtfelder."
-        extra_context["generate_rental_pdf"] = True
-        return super().change_view(request, object_id, form_url, extra_context=extra_context)
-
-    def response_change(self, request, obj):
-        if "_generate_rental_pdf" in request.POST:
-            if generate_rental_pdf(obj):
-                self.message_user(
-                    request,
-                    "Neues Verleihformular wurde generiert.",
-                    messages.SUCCESS,
-                )
-            else:
-                self.message_user(
-                    request,
-                    (
-                        "Das PDF-Dokument konnte nicht generiert werden, da der Status nicht auf "
-                        "'Verleih genehmigt' gesetzt ist."
-                    ),
-                    messages.WARNING,
-                )
-            return HttpResponseRedirect(".")
-        return super().response_change(request, obj)
-
-    def save_model(self, request, obj, form, change):
-        obj.author = request.user
-        super().save_model(request, obj, form, change)
-
-    @admin.display(description="Kaution (EUR)")
-    def total_disposit(self, obj):
-        total_disposit = 0
-        for elem in obj.rentalitems.all():
-            total_disposit += elem.deposit
-
-        return f"{total_disposit}"
-
-
-@admin.register(RentalItem)
-class RentalItemAdmin(admin.ModelAdmin):
-    form = RentalItemAdminForm
-    model = RentalItem
-
-    ordering = ["name"]
-
-    def add_view(self, request, form_url="", extra_context=None):
-        extra_context = extra_context or {}
-        extra_context["help_text"] = "Fette Schriften sind Pflichtfelder."
-        return super().add_view(request, form_url, extra_context=extra_context)
-
-    def change_view(self, request, object_id, form_url="", extra_context=None):
-        extra_context = extra_context or {}
-        extra_context["help_text"] = "Fette Schriften sind Pflichtfelder."
-        return super().change_view(request, object_id, form_url, extra_context=extra_context)
-
-    def save_model(self, request, obj, form, change):
-        obj.author = request.user
-        super().save_model(request, obj, form, change)
+from django.contrib import admin, messages
+from django.http import HttpResponseRedirect
+
+from .forms import RentalAdminForm, RentalItemAdminForm
+from .models import Rental, RentalItem
+from .utils import generate_rental_pdf
+
+
+@admin.register(Rental)
+class RentalAdmin(admin.ModelAdmin):
+    form = RentalAdminForm
+    model = Rental
+
+    list_display = [
+        "id",
+        "firstname",
+        "surname",
+        "status",
+        "total_disposit",
+        "date_start",
+        "date_end",
+    ]
+    ordering = ["-id"]
+
+    readonly_fields = ["total_disposit"]
+
+    fieldsets = (
+        (
+            "Persönliche Daten",
+            {
+                "fields": (
+                    ("firstname", "surname"),
+                    ("organization", "matriculation_number"),
+                    ("email", "phone"),
+                ),
+            },
+        ),
+        (
+            "Verleih",
+            {
+                "fields": (
+                    ("date_start", "date_end"),
+                    "reason",
+                    "rentalitems",
+                    ("total_disposit", "intern"),
+                ),
+            },
+        ),
+        (
+            "Sonstiges",
+            {
+                "fields": (
+                    "comment",
+                    "file_field",
+                    "status",
+                ),
+            },
+        ),
+    )
+
+    def add_view(self, request, form_url="", extra_context=None):
+        extra_context = extra_context or {}
+        extra_context["help_text"] = "Fette Schriften sind Pflichtfelder."
+        return super().add_view(request, form_url, extra_context=extra_context)
+
+    def change_view(self, request, object_id, form_url="", extra_context=None):
+        extra_context = extra_context or {}
+        extra_context["help_text"] = "Fette Schriften sind Pflichtfelder."
+        extra_context["generate_rental_pdf"] = True
+        return super().change_view(request, object_id, form_url, extra_context=extra_context)
+
+    def response_change(self, request, obj):
+        if "_generate_rental_pdf" in request.POST:
+            if generate_rental_pdf(obj):
+                self.message_user(
+                    request,
+                    "Neues Verleihformular wurde generiert.",
+                    messages.SUCCESS,
+                )
+            else:
+                self.message_user(
+                    request,
+                    (
+                        "Das PDF-Dokument konnte nicht generiert werden, da der Status nicht auf "
+                        "'Verleih genehmigt' gesetzt ist."
+                    ),
+                    messages.WARNING,
+                )
+            return HttpResponseRedirect(".")
+        return super().response_change(request, obj)
+
+    def save_model(self, request, obj, form, change):
+        obj.author = request.user
+        super().save_model(request, obj, form, change)
+
+    @admin.display(description="Kaution insgesamt")
+    def total_disposit(self, obj):
+        total_disposit = obj.calc_total_deposit()
+        return f"{total_disposit} €"
+
+
+@admin.register(RentalItem)
+class RentalItemAdmin(admin.ModelAdmin):
+    form = RentalItemAdminForm
+    model = RentalItem
+
+    ordering = ["name"]
+
+    def add_view(self, request, form_url="", extra_context=None):
+        extra_context = extra_context or {}
+        extra_context["help_text"] = "Fette Schriften sind Pflichtfelder."
+        return super().add_view(request, form_url, extra_context=extra_context)
+
+    def change_view(self, request, object_id, form_url="", extra_context=None):
+        extra_context = extra_context or {}
+        extra_context["help_text"] = "Fette Schriften sind Pflichtfelder."
+        return super().change_view(request, object_id, form_url, extra_context=extra_context)
+
+    def save_model(self, request, obj, form, change):
+        obj.author = request.user
+        super().save_model(request, obj, form, change)

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/mails.py

@@ -1,53 +1,53 @@
-import logging
-
-from django.core.mail import EmailMessage
-
-RENTAL_EMAIL = "verleih@fet.at"
-logger = logging.getLogger(__name__)
-
-
-def send_mail_approved(obj):
-    subject = f"FET-Verleih #{obj.id}: {obj.get_status_display()}"
-
-    total_deposit = 0
-    for rentalitem in obj.rentalitems.all():
-        total_deposit += rentalitem.deposit
-
-    message = (
-        f"Hallo {obj.firstname},\n"
-        f"deine Verleihanfrage mit der Nummer #{obj.id} wurde erfolgreich genehmigt. Die "
-        f"Gegenstände können am {obj.date_start.strftime('%d.%m.%Y')} während der Beratungszeit "
-        "(Montag - Donnerstag: 09:00 - 14:00, Freitag: 09:00 - 12:00) abgeholt werden. Bitte bring "
-        f"den Gesamtpfand in Höhe von {total_deposit} € in bar mit.\n"
-        "Liebe Grüße,\n"
-        "das Verleih-Team"
-    )
-
-    email = EmailMessage(
-        subject, message, from_email=RENTAL_EMAIL, to=[obj.email], cc=[RENTAL_EMAIL]
-    )
-
-    try:
-        email.send()
-    except Exception as exc:
-        logger.error("Failed to send approval email for rental #%s. Error: %s", obj.id, exc)
-
-
-def send_mail_rejected(obj):
-    subject = f"FET-Verleih #{obj.id}: {obj.get_status_display()}"
-
-    message = (
-        f"Hallo {obj.firstname},\n"
-        f"deine Verleihanfrage mit der Nummer #{obj.id} wurde abgelehnt.\n"
-        "Liebe Grüße,\n"
-        "das Verleih-Team"
-    )
-
-    email = EmailMessage(
-        subject, message, from_email=RENTAL_EMAIL, to=[obj.email], cc=[RENTAL_EMAIL]
-    )
-
-    try:
-        email.send()
-    except Exception as exc:
-        logger.error("Failed to send rejection email for rental #%s. Error: %s", obj.id, exc)
+import logging
+
+from django.conf import settings
+from django.core.mail import EmailMessage
+
+RENTAL_EMAIL = settings.EMAIL_HOST_USER
+logger = logging.getLogger(__name__)
+
+
+def send_mail_approved(obj):
+    subject = f"FET-Verleih #{obj.id}: {obj.get_status_display()}"
+    total_deposit = obj.calc_total_deposit()
+
+    message = (
+        f"Hallo {obj.firstname},\n\n"
+        f"deine Verleihanfrage mit der Nummer #{obj.id} wurde erfolgreich genehmigt. Die "
+        f"Gegenstände können am {obj.date_start.strftime('%d.%m.%Y')} während der Beratungszeit "
+        "(Montag - Donnerstag: 09:00 - 14:00, Freitag: 09:00 - 12:00) abgeholt werden.\n"
+    )
+
+    if total_deposit > 0:
+        message += f"Bitte bring den Gesamtpfand in Höhe von {total_deposit} € in bar mit.\n"
+
+    message += "\nLiebe Grüße,\ndas Verleih-Team"
+
+    email = EmailMessage(
+        subject, message, from_email=RENTAL_EMAIL, to=[obj.email], cc=[RENTAL_EMAIL]
+    )
+
+    try:
+        email.send()
+    except Exception as exc:
+        logger.info("Failed to send approval email for rental #%s. Error: %s", obj.id, exc)
+
+
+def send_mail_rejected(obj):
+    subject = f"FET-Verleih #{obj.id}: {obj.get_status_display()}"
+
+    message = (
+        f"Hallo {obj.firstname},\n\n"
+        f"deine Verleihanfrage mit der Nummer #{obj.id} wurde abgelehnt.\n\n"
+        "Liebe Grüße,\n"
+        "das Verleih-Team"
+    )
+
+    email = EmailMessage(
+        subject, message, from_email=RENTAL_EMAIL, to=[obj.email], cc=[RENTAL_EMAIL]
+    )
+
+    try:
+        email.send()
+    except Exception as exc:
+        logger.info("Failed to send rejection email for rental #%s. Error: %s", obj.id, exc)

fet2020/rental/managers.py

@@ -0,0 +1,6 @@
+from django.db import models
+
+
+class RentalItemsManager(models.Manager):
+    def get_queryset(self):
+        return super().get_queryset().order_by("name")

fet2020/rental/migrations/0001_initial.py

@@ -0,0 +1,55 @@
+# Generated by Django 5.2.7 on 2025-10-30 12:05
+
+import django.core.validators
+import rental.validators
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='RentalItem',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(max_length=128, verbose_name='Name')),
+                ('description', models.CharField(blank=True, default='', max_length=128, verbose_name='Beschreibung')),
+                ('deposit', models.DecimalField(decimal_places=2, default=0, max_digits=6, verbose_name='Kaution (EUR)')),
+                ('image', models.ImageField(blank=True, null=True, upload_to='rentalitems', verbose_name='Bild')),
+                ('induction', models.BooleanField(default=False, verbose_name='Einschulung notwendig')),
+                ('location', models.CharField(blank=True, default='', max_length=128, verbose_name='Standort')),
+            ],
+            options={
+                'verbose_name': 'Verleihgegenstand',
+                'verbose_name_plural': 'Verleihgegenstände',
+            },
+        ),
+        migrations.CreateModel(
+            name='Rental',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('firstname', models.CharField(max_length=128, verbose_name='Vorname')),
+                ('surname', models.CharField(max_length=128, verbose_name='Nachname')),
+                ('matriculation_number', models.CharField(max_length=8, verbose_name='Matrikelnummer')),
+                ('email', models.EmailField(max_length=254, verbose_name='E-Mail')),
+                ('phone', models.CharField(max_length=32, validators=[rental.validators.PhoneNumberValidator()], verbose_name='Telefonnummer')),
+                ('organization', models.CharField(max_length=128, verbose_name='Organisation')),
+                ('date_start', models.DateField(verbose_name='Abholdatum')),
+                ('date_end', models.DateField(verbose_name='Rückgabedatum')),
+                ('reason', models.TextField(max_length=500, verbose_name='Grund der Ausleihe')),
+                ('comment', models.TextField(blank=True, default='', max_length=500, verbose_name='Kommentar')),
+                ('file_field', models.FileField(blank=True, null=True, upload_to='uploads/rental/rental/', validators=[django.core.validators.FileExtensionValidator(['pdf'])], verbose_name='Verleihformular')),
+                ('status', models.CharField(choices=[('S', 'Eingereicht'), ('A', 'Verleih genehmigt'), ('J', 'Verleih abgelehnt'), ('I', 'Verleihgegenstände ausgegeben'), ('R', 'Verleihgegenstände zurückgegeben')], default='S', max_length=1, verbose_name='Status')),
+                ('rentalitems', models.ManyToManyField(to='rental.rentalitem', verbose_name='Verleihgegenstände')),
+            ],
+            options={
+                'verbose_name': 'Verleih',
+                'verbose_name_plural': 'Verleih',
+            },
+        ),
+    ]

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/models.py

@@ -3,6 +3,7 @@ from django.db import models
 from django.forms import ValidationError
 
 from .mails import send_mail_approved, send_mail_rejected
+from .managers import RentalItemsManager
 from .validators import PhoneNumberValidator
 
 
@@ -22,6 +23,8 @@ class RentalItem(models.Model):
 
     location = models.CharField(verbose_name="Standort", max_length=128, blank=True, default="")
 
+    objects = RentalItemsManager()
+
     class Meta:
         verbose_name = "Verleihgegenstand"
         verbose_name_plural = "Verleihgegenstände"
@@ -41,6 +44,7 @@ class Rental(models.Model):
     )
 
     organization = models.CharField(verbose_name="Organisation", max_length=128)
+    intern = models.BooleanField(verbose_name="Interner Verleih", default=False)
 
     date_start = models.DateField(verbose_name="Abholdatum")
     date_end = models.DateField(verbose_name="Rückgabedatum")
@@ -107,3 +111,12 @@ class Rental(models.Model):
 
         if self.date_start > self.date_end:
             raise ValidationError("Das Abholdatum muss vor dem Rückgabedatum liegen.")
+
+    def calc_total_deposit(self) -> int:
+        total_deposit = 0
+
+        if not self.intern:
+            for item in self.rentalitems.all():
+                total_deposit += item.deposit
+
+        return total_deposit

fet2020/rental/urls.py

@@ -10,7 +10,7 @@ urlpatterns = [
     path("overview/", RentalListView.as_view(), name="index"),
     path("request-rental/", RentalCreateView.as_view(), name="rental_create"),
     path(
-        "request-rental/<int:pk>/done/",
+        "request-rental/done/",
         RentalCreateDoneView.as_view(),
         name="rental_create_done",
     ),

fet2020/rental/utils.py

@@ -1,66 +1,61 @@
-import io
-from pathlib import Path
-
-from django.core.files import File
-from pypdf import PdfReader, PdfWriter
-
-from .models import Rental
-
-
-def generate_rental_pdf(rental: Rental) -> bool:
-    if not rental or rental.status != Rental.Status.APPROVED:
-        return False
-
-    # Get data for pdf
-    data = {}
-    data.update(
-        {
-            "Vorname": rental.firstname,
-            "Nachname": rental.surname,
-            "Orga": rental.organization,
-            "Matrikelnummer": rental.matriculation_number,
-            "E-Mail": rental.email,
-            "Telefonnummer": rental.phone,
-            # Change to the correct date format
-            "Abholdatum": str(rental.date_start.strftime("%d.%m.%Y")),
-            "Rückgabedatum": str(rental.date_end.strftime("%d.%m.%Y")),
-        },
-    )
-
-    total_deposit = 0
-
-    for i, item in enumerate(rental.rentalitems.all(), start=1):
-        total_deposit += item.deposit
-        data.update(
-            {
-                f"Produkt Row{i}": item.name,
-                f"Menge Row{i}": "1",
-                f"Kaution Row{i}": item.deposit,
-            },
-        )
-
-    data.update(
-        {
-            "Gesamtkaution": total_deposit,
-        },
-    )
-
-    # Write data in pdf
-    pdf_path = Path(Path(__file__).parent) / "static/rental/Verleihformular.pdf"
-    reader = PdfReader(pdf_path)
-    writer = PdfWriter()
-    writer.append(reader)
-
-    writer.update_page_form_field_values(
-        writer.pages[0],
-        data,
-    )
-
-    with io.BytesIO() as bytes_stream:
-        writer.write(bytes_stream)
-
-        # Save pdf in rental
-        rental_name = f"Verleihformular-{str(rental.pk).zfill(4)}.pdf"
-        rental.file_field.save(rental_name, File(bytes_stream, rental_name))
-
-    return True
+import io
+
+from django.contrib.staticfiles import finders
+from django.core.files import File
+from pypdf import PdfReader, PdfWriter
+
+from .models import Rental
+
+
+def generate_rental_pdf(rental: Rental) -> bool:
+    if not rental or rental.status != Rental.Status.APPROVED:
+        return False
+
+    # Get data for pdf
+    data = {}
+    data.update(
+        {
+            "Vorname": rental.firstname,
+            "Nachname": rental.surname,
+            "Orga": rental.organization,
+            "Matrikelnummer": rental.matriculation_number,
+            "E-Mail": rental.email,
+            "Telefonnummer": rental.phone,
+            # Change to the correct date format
+            "Abholdatum": str(rental.date_start.strftime("%d.%m.%Y")),
+            "Rückgabedatum": str(rental.date_end.strftime("%d.%m.%Y")),
+        },
+    )
+
+    for i, item in enumerate(rental.rentalitems.all(), start=1):
+        data.update(
+            {
+                f"Produkt Row{i}": item.name,
+                f"Menge Row{i}": "1",
+                f"Kaution Row{i}": (str(item.deposit) if not rental.intern else "0"),
+            },
+        )
+
+    total_deposit = rental.calc_total_deposit()
+    data.update({"Gesamtkaution": str(total_deposit)})
+
+    # Write data in pdf
+    pdf_path_str = finders.find("rental/Verleihformular.pdf")
+    reader = PdfReader(pdf_path_str)
+    writer = PdfWriter()
+    writer.append(reader)
+
+    writer.update_page_form_field_values(
+        writer.pages[0],
+        data,
+    )
+
+    with io.BytesIO() as bytes_stream:
+        writer.write(bytes_stream)
+        bytes_stream.seek(0)
+
+        # Save pdf in rental
+        rental_name = f"Verleihformular-{str(rental.pk).zfill(4)}.pdf"
+        rental.file_field.save(rental_name, File(bytes_stream, rental_name))
+
+    return True

fet2020/rental/views.py

@@ -3,8 +3,10 @@ import datetime
 from datetime import date
 
 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
@@ -12,6 +14,9 @@ from django.views.generic.edit import CreateView
 from .forms import RentalCreateForm
 from .models import Rental, RentalItem
 
+# Maximum number of rental items per rental entry because of table size limitations in PDF file
+RENTAL_ITEMS_MAX = 5
+
 
 def _calc_days_from_current_month(month: date) -> list:
     last_day_of_month = month.replace(day=calendar.monthrange(month.year, month.month)[1])
@@ -60,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
@@ -72,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
 
@@ -166,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()
@@ -185,7 +190,7 @@ class RentalListView(ListView):
                     if rental["rentalitems__name"] not in rental_dict[day]:
                         rental_dict[day].append(rental["rentalitems__name"])
 
-        context["rental_dict"] = rental_dict
+        context["rental_dict"] = {k: sorted(v, key=str.casefold) for k, v in rental_dict.items()}
 
         return context
 
@@ -223,6 +228,35 @@ class RentalCreateView(CreateView):
     model = Rental
     template_name = "rental/create.html"
 
+    def form_valid(self, form):
+        # Get unsaved base Rental with all form data
+        base_rental = form.save(commit=False)
+        items = list(form.cleaned_data["rentalitems"])
+        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]
+
+            # Clone base_rental — copying all its field values
+            new_rental = Rental.objects.create(
+                firstname=base_rental.firstname,
+                surname=base_rental.surname,
+                matriculation_number=base_rental.matriculation_number,
+                email=base_rental.email,
+                phone=base_rental.phone,
+                organization=base_rental.organization,
+                date_start=base_rental.date_start,
+                date_end=base_rental.date_end,
+                reason=base_rental.reason,
+                comment=base_rental.comment,
+                status=base_rental.status,
+            )
+
+            # Important: Add M2M relations after the object has been saved
+            new_rental.rentalitems.add(*batch)
+
+        return HttpResponseRedirect(self.get_success_url())
+
     def get_context_data(self, **kwargs):
         context = super().get_context_data(**kwargs)
 
@@ -231,26 +265,12 @@ class RentalCreateView(CreateView):
         return context
 
     def get_success_url(self):
-        return reverse("rental:rental_create_done", kwargs={"pk": self.object.pk})
+        return reverse("rental:rental_create_done")
 
 
 class RentalCreateDoneView(TemplateView):
     template_name = "rental/create_done.html"
 
-    def get_context_data(self, **kwargs):
-        context = super().get_context_data(**kwargs)
-
-        obj = Rental.objects.get(pk=self.kwargs["pk"])
-
-        total_deposit = 0
-        for elem in obj.rentalitems.all():
-            total_deposit += elem.deposit
-
-        context["object"] = obj
-        context["total_deposit"] = total_deposit
-
-        return context
-
 
 class RentalItemDetailView(DetailView):
     model = RentalItem

fet2020/templates/rental/create_done.html

@@ -1,17 +1,22 @@
-{% extends 'base.html' %}
-
-{% block title %}Verleihanfrage erfolgreich eingereicht{% endblock %}
-
-{% block content %}
-<!-- Main Content -->
-<main class="container mx-auto w-full px-4 my-8 flex-1 max-w-2xl">
-    <section class="block w-full">
-        <p class="mt-6 text-gray-900 dark:text-gray-100 hyphens-auto" lang="de">
-            Deine Verleihanfrage mit der Nummer #{{ pk }} wurde erfolgreich eingereicht. Die Gegenstände können am {{ object.date_start }} während der Beratungszeit (Montag - Donnerstag: 09:00 - 14:00, Freitag: 09:00 - 12:00) abgeholt werden. Bitte bring den Gesamtpfand in Höhe von {{ total_deposit }} € in bar mit.
-        </p>
-        <div class="mt-10 flex items-center justify-center">
-            <a href="{% url 'home' %}" type="submit" class="block btn btn-primary">Zur Startseite</a>
-        </div>
-    </section>
-</main>
-{% endblock content %}
+{% extends 'base.html' %}
+
+{% block title %}Verleihanfrage erfolgreich eingereicht{% endblock %}
+
+{% block content %}
+<!-- Main Content -->
+<main class="container mx-auto w-full px-4 my-8 flex-1 max-w-2xl">
+  <section class="block w-full">
+    <p class="mt-6 text-gray-900 dark:text-gray-100 hyphens-auto" lang="de">
+      Deine Verleihanfrage ist eingegangen - danke dir! 🎉
+      Wir kümmern uns jetzt darum und melden uns per E-Mail mit den nächsten Schritten.
+    </p>
+    <p class="mt-6 text-gray-900 dark:text-gray-100 hyphens-auto" lang="de">
+      Kleiner Hinweis: Bevor du die Sachen abholen kannst, wird deine Anfrage kurz geprüft und freigegeben.
+      Sobald alles genehmigt ist, bekommst du von uns eine Mail.
+    </p>
+    <div class="mt-10 flex items-center justify-center">
+      <a href="{% url 'home' %}" type="submit" class="block btn btn-primary">Zur Startseite</a>
+    </div>
+  </section>
+</main>
+{% endblock content %}