diff --git a/fet2020/documents/api.py b/fet2020/documents/api.py
index ee6a060a..6b3ade47 100644
--- a/fet2020/documents/api.py
+++ b/fet2020/documents/api.py
@@ -22,7 +22,7 @@ def get_ep_client():
         api_key = f.read()
         api_key = api_key.rstrip()
 
-    if api_key == "":
+    if not api_key:
         logger.info("API Key is missing. Path: %s", api_key_path)
         return None
 
@@ -56,97 +56,114 @@ def get_ep_group(ep_group_name: str = "fet") -> dict[str, str]:
     return ep_group
 
 
-def ep_pad_exists(pad_id: str | None = None) -> bool | None:
+def ep_pad_exists(pad_id: str = "") -> bool:
     """Check if pad exists.
 
     Parameters
     ----------
-    pad_id : str | None
+    pad_id : str
         Id of pad that is checked if it exists.
 
     Returns
     -------
-    bool | None
+    bool
         - True: Pad exists.
-        - False: Pad doesn't exist.
+        - False: Pad not found.
         - None: There is no pad id or no connection to etherpad server.
     """
-    if pad_id is None:
+    if not pad_id:
         return None
 
-    if (ep_c := get_ep_client()) is None:
+    if not (ep_c := get_ep_client()):
         return None
 
-    if (ep_group := get_ep_group()) is None:
+    if not (ep_group := get_ep_group()):
         return None
 
     lists = ep_c.listPads(groupID=ep_group["groupID"])
     if any(pad_id in s for s in lists["padIDs"]):
-        logger.info("Etherpad exists. Pad: %s", pad_id)
+        logger.info("Etherpad '%s' exists.", pad_id)
         return True
 
-    logger.info("Etherpad doesn't exist. Pad: %s", pad_id)
+    logger.info("Etherpad '%s' not found.", pad_id)
     return False
 
 
-def ep_create_new_pad(pad_id: str | None, text="helloworld"):
+def ep_create_new_pad(pad_id: str, text="helloworld") -> str:
+    """Create a new pad if it doesn't exist.
+
+    Parameters
+    ----------
+    pad_id : str
+        Id of the new pad to be created.
+    text : str
+        Text for new pad.
+
+    Returns
+    -------
+    str
+        Id of the new pad.
+        - None: No pad is created.
     """
-    Create a pad if it doesn't exist.
-
-    Return a pad_id if new pad is created. Otherwise None (when the padID exists already).
-    """
-    if pad_id is None:
+    if not pad_id:
         return None
 
-    if (ep_c := get_ep_client()) is None:
+    if not (ep_c := get_ep_client()):
         return None
 
-    if (ep_group := get_ep_group()) is None:
-        return None
-
-    if ep_pad_exists(pad_id) is False:
-        ep_c.createGroupPad(groupID=ep_group["groupID"], padName=pad_id, text=text)
-        logger.info("Create new etherpad. Pad: %s", pad_id)
-        return pad_id
-
-    return None
-
-
-def ep_get_html(pad_id: str | None) -> str | None:
-    if (ep_c := get_ep_client()) is None:
-        return None
-
-    if (ep_group := get_ep_group()) is None:
+    if not (ep_group := get_ep_group()):
         return None
 
     if ep_pad_exists(pad_id):
-        return ep_c.getHTML(padID=ep_group["groupID"] + "$" + pad_id)["html"]
-
-    return ""
-
-
-def ep_set_html(pad_id: str | None, html: str):
-    if (ep_c := get_ep_client()) is None:
+        logger.info("Can't create new etherpad '%s' because it already exists.", pad_id)
         return None
 
-    if (ep_group := get_ep_group()) is None:
+    ep_c.createGroupPad(groupID=ep_group["groupID"], padName=pad_id, text=text)
+    logger.info("Create new etherpad '%s'.", pad_id)
+    return pad_id  
+
+
+def ep_get_html(pad_id: str) -> str:
+    if not pad_id:
+        return None
+        
+    if not (ep_c := get_ep_client()):
         return None
 
-    if ep_pad_exists(pad_id):
-        ep_c.setHTML(padID=ep_group["groupID"] + "$" + pad_id, html=html)
-        return True
-
-    return None
-
-
-def ep_get_url(pad_id: str | None):
-    if (ep_group := get_ep_group()) is None:
+    if not (ep_group := get_ep_group()):
         return None
 
-    if ep_pad_exists(pad_id):
-        return urljoin(
-            settings.ETHERPAD_CLIENT["exturl"],
-            "p/" + ep_group["groupID"] + "$" + str(pad_id),
-        )
+    if not ep_pad_exists(pad_id):
+        return None
+        
+    return ep_c.getHTML(padID=ep_group["groupID"] + "$" + pad_id)["html"]
 
-    return "#"
+
+def ep_set_html(pad_id: str, html: str) -> bool:
+    if not pad_id:
+        return None
+ 
+    if not (ep_c := get_ep_client()):
+        return None
+
+    if not (ep_group := get_ep_group()):
+        return None
+
+    if not ep_pad_exists(pad_id):
+        return None
+    
+    ep_c.setHTML(padID=ep_group["groupID"] + "$" + pad_id, html=html)
+    return True
+
+
+def ep_get_url(pad_id: str):
+    if not pad_id:
+        return None
+
+    if not (ep_group := get_ep_group()):
+        return None
+
+    if not ep_pad_exists(pad_id):
+        return None
+
+    return urljoin(settings.ETHERPAD_CLIENT["exturl"], "p/" + ep_group["groupID"] + "$" + str(pad_id))
diff --git a/fet2020/documents/etherpadlib.py b/fet2020/documents/etherpadlib.py
index 6bfeb894..2bc50c01 100644
--- a/fet2020/documents/etherpadlib.py
+++ b/fet2020/documents/etherpadlib.py
@@ -10,11 +10,11 @@ from .api import get_ep_client, get_ep_group
 
 @ep_authenticated_user
 def _create_ep_session(request, expires):
-    if (ep_c := get_ep_client()) is None:
+    if not (ep_c := get_ep_client()):
         return None
 
-    if (ep_group := get_ep_group()) is None:
-        return None, None
+    if not (ep_group := get_ep_group()):
+        return None
 
     author = ep_c.createAuthorIfNotExistsFor(
         name=str(request.user),
diff --git a/fet2020/fet2020/views.py b/fet2020/fet2020/views.py
index 7e1b65a5..8b1ae9d0 100644
--- a/fet2020/fet2020/views.py
+++ b/fet2020/fet2020/views.py
@@ -6,7 +6,7 @@ from posts.models import Event, FetMeeting, Post
 
 
 def index(request):
-    posts = Post.articles.date_sorted_list()
+    posts = Post.articles.date_sorted()
     # A maximum of 5 posts should be displayed on the startpage.
     post_count = 5
 
diff --git a/fet2020/posts/admin.py b/fet2020/posts/admin.py
index 2975b5cc..d9556083 100644
--- a/fet2020/posts/admin.py
+++ b/fet2020/posts/admin.py
@@ -10,8 +10,7 @@ from .models import Event, FetMeeting, FileUpload, News, Post
 def make_fetmeeting(self, request, queryset):
     qs = self.get_queryset(request).filter(id=request.POST["_selected_action"]).first()
 
-    agenda_key = ep_create_new_pad(qs.slug + "-agenda")
-    if not agenda_key:
+    if not (agenda_key := ep_create_new_pad(qs.slug + "-agenda")):
         self.message_user(
             request,
             "Das Agenda konnte nicht erstellt werden.",
@@ -19,8 +18,7 @@ def make_fetmeeting(self, request, queryset):
         )
         return
 
-    protocol_key = ep_create_new_pad(qs.slug + "-protocol")
-    if not protocol_key:
+    if not (protocol_key := ep_create_new_pad(qs.slug + "-protocol")):
         self.message_user(
             request,
             "Das Protokoll konnte nicht erstellt werden.",
@@ -79,7 +77,7 @@ class PostAdmin(admin.ModelAdmin):
         )
 
     def save_model(self, request, obj, form, change):
-        if obj.author is None:
+        if not obj.author:
             obj.author = request.user
         super().save_model(request, obj, form, change)
 
diff --git a/fet2020/posts/choices.py b/fet2020/posts/choices.py
new file mode 100644
index 00000000..77fc848d
--- /dev/null
+++ b/fet2020/posts/choices.py
@@ -0,0 +1,13 @@
+from django.db import models
+
+
+class PostType(models.TextChoices):
+    NEWS = "N", "News"
+    EVENT = "E", "Event"
+    FETMEETING = "F", "FetMeeting"
+
+
+class Status(models.TextChoices):
+    DRAFT = "10", "DRAFT"
+    ONLY_INTERN = "15", "ONLY_INTERN"
+    PUBLIC = "20", "PUBLIC"
diff --git a/fet2020/posts/managers.py b/fet2020/posts/managers.py
index c8665846..9261173a 100644
--- a/fet2020/posts/managers.py
+++ b/fet2020/posts/managers.py
@@ -2,7 +2,8 @@ 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):
@@ -10,33 +11,36 @@ class PublishedManager(models.Manager):
         """
         publish all posts with status 'PUBLIC'
         """
-        qs = self.get_queryset().filter(status="20") if public else self.get_queryset()
-        return qs
+        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'
         """
-        qs = self.get_queryset().filter(~Q(status="10")) if public else self.get_queryset()
-        return qs
+        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()
-        qs = qs.annotate(
-            date=Case(
-                When(post_type="N", then="public_date"),
-                When(post_type="E", then="event_start__date"),
-                When(post_type="F", then="event_start__date"),
-            ),
+        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_list(self, public=True):
+    def date_sorted(self, public=True):
         return self.published(public)
 
-    def date_filtered_list(
+    def date_filter(
         self,
         public=True,
         year=None,
@@ -46,7 +50,7 @@ class PostManager(PublishedManager, models.Manager):
         qs_filter = Q()
 
         if fet_meeting_only:
-            qs_filter &= Q(post_type="F")
+            qs_filter &= Q(post_type=PostType.FETMEETING)
 
         if year:
             qs_filter &= Q(date__year=year)
@@ -63,16 +67,16 @@ class ArticleManager(PublishedManager, models.Manager):
     """
 
     def get_queryset(self):
-        qs = super().get_queryset().filter(Q(post_type="N") | Q(post_type="E"))
+        qs = super().get_queryset().filter(Q(post_type=PostType.NEWS) | Q(post_type=PostType.EVENT))
         qs = qs.annotate(
             date=Case(
-                When(post_type="N", then="public_date"),
-                When(post_type="E", then="event_start__date"),
+                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_list(self, public=True):
+    def date_sorted(self, public=True):
         return self.published(public)
 
     def pinned(self, public=True):
@@ -95,10 +99,12 @@ class ArticleManager(PublishedManager, models.Manager):
 
         return (
             self.published(public)
-            .filter(is_pinned=True)
             .filter(
-                (Q(post_type="N") & Q(public_date__gt=post_date))
-                | (Q(post_type="E") & Q(event_end__date__gt=event_date)),
+                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()
         )
@@ -110,10 +116,10 @@ class NewsManager(PublishedManager, models.Manager):
     """
 
     def get_queryset(self):
-        qs = super().get_queryset().filter(post_type="N")
+        qs = super().get_queryset().filter(post_type=PostType.NEWS)
         qs = qs.annotate(
             date=Case(
-                When(post_type="N", then="public_date"),
+                When(post_type=PostType.NEWS, then="public_date"),
             ),
         )
         return qs.order_by("-date")
@@ -125,17 +131,21 @@ class AllEventManager(PublishedManager, models.Manager):
     """
 
     def get_queryset(self):
-        qs = super().get_queryset().filter(Q(post_type="E") | Q(post_type="F"))
+        qs = (
+            super()
+            .get_queryset()
+            .filter(Q(post_type=PostType.EVENT) | Q(post_type=PostType.FETMEETING))
+        )
         qs = qs.annotate(
             date=Case(
-                When(post_type="E", then="event_start__date"),
-                When(post_type="F", then="event_start__date"),
+                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_today = datetime.date.today()
         qs = self.published(public).filter(event_start__gt=date_today)
         return qs.reverse()
 
@@ -147,21 +157,21 @@ class EventManager(PublishedManager, models.Manager):
     """
 
     def get_queryset(self):
-        qs = super().get_queryset().filter(post_type="E")
+        qs = super().get_queryset().filter(post_type=PostType.EVENT)
         qs = qs.annotate(
             date=Case(
-                When(post_type="E", then="event_start__date"),
+                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_today = datetime.date.today()
         qs = self.published(public).filter(event_start__gt=date_today)
         return qs.reverse()
 
     def past_events(self, public=True):
-        date_today = timezone.now()
+        date_today = datetime.date.today()
         qs = self.published(public).filter(event_start__lt=date_today)
         return qs
 
@@ -172,20 +182,20 @@ class FetMeetingManager(PublishedManager, models.Manager):
     """
 
     def get_queryset(self):
-        qs = super().get_queryset().filter(post_type="F")
+        qs = super().get_queryset().filter(post_type=PostType.FETMEETING)
         qs = qs.annotate(
             date=Case(
-                When(post_type="F", then="event_start__date"),
+                When(post_type=PostType.FETMEETING, then="event_start__date"),
             ),
         )
         return qs.order_by("-date")
 
     def future_events(self):
-        date_today = timezone.now()
+        date_today = datetime.date.today()
         qs = self.published().filter(event_start__gt=date_today)
         return qs.reverse()
 
     def past_events(self):
-        date_today = timezone.now()
+        date_today = datetime.date.today()
         qs = self.published().filter(event_start__lt=date_today)
         return qs
diff --git a/fet2020/posts/models.py b/fet2020/posts/models.py
index d225ddf2..12719593 100644
--- a/fet2020/posts/models.py
+++ b/fet2020/posts/models.py
@@ -8,18 +8,12 @@ from django.db import models
 from django.urls import reverse
 from django.utils import timezone
 from django.utils.text import slugify
-from django.utils.translation import gettext_lazy as _
 from taggit.managers import TaggableManager
 
 from core.models import CustomFlatPage
-from documents.api import (
-    ep_create_new_pad,
-    ep_get_html,
-    ep_get_url,
-    ep_pad_exists,
-    ep_set_html,
-)
+from documents.api import ep_create_new_pad, ep_get_html, ep_get_url, ep_pad_exists, ep_set_html
 
+from .choices import PostType, Status
 from .managers import (
     AllEventManager,
     ArticleManager,
@@ -30,44 +24,21 @@ from .managers import (
 )
 
 logger = logging.getLogger(__name__)
-request_logger = logging.getLogger("django.request")
 
 
 def create_pad_for_post(slug, item="agenda"):
-    """
-    Create a Etherpad pad.
-
-    Return a Etherpad key.
-    """
-    logger.info(f"Pad-Type: {item}")
+    logger.info("Pad-Type: %s", item)
 
     pad_id = slug + "-" + item
-    if ep_create_new_pad(pad_id):
-        # Set template into the newly created pad if it exists.
-        if page := CustomFlatPage.objects.filter(title__iexact=item).first():
-            ep_set_html(pad_id, page.content)
-            logger.info(f"Template is set. Template: {page.title}")
+    if not ep_create_new_pad(pad_id):
+        return ""
 
-        return pad_id
+    # Set template into the newly created pad if it exists.
+    if page := CustomFlatPage.objects.filter(title__iexact=item).first():
+        ep_set_html(pad_id, page.content)
+        logger.info("Template '%s' is set.", page.title)
 
-    return "#"
-
-
-class Category(models.Model):
-    # Titel des Posts
-    title = models.CharField(max_length=200)
-
-    subtitle = models.CharField(max_length=500, null=True, blank=True)
-    # Slug = Text Basierter url bestandteil zb Fetsitzung 22.1.2020 --> fetsitzung_22_1_2020 für Url
-    slug = models.SlugField(unique=True, null=True, blank=True)
-    # Ein Haupt Bild für den Post
-    image = models.ImageField(null=True, blank=True)
-
-    tags = TaggableManager(blank=True)
-
-    class Meta:
-        verbose_name = "Category"
-        verbose_name_plural = "Categories"
+    return pad_id
 
 
 class Post(models.Model):
@@ -75,13 +46,12 @@ class Post(models.Model):
     legacy_id = models.IntegerField(null=True, blank=True)
 
     title = models.CharField(verbose_name="Titel", max_length=200)
-    subtitle = models.CharField(max_length=500, null=True, blank=True)
+    subtitle = models.CharField(max_length=500, blank=True, default="")
     tags = TaggableManager(blank=True)
 
-    # Slug = Text Basierter url bestandteil zb Fetsitzung 22.1.2020 --> fetsitzung_22_1_2020 für Url
     slug = models.SlugField(unique=True, blank=True)
 
-    body = models.TextField(null=True, blank=True)
+    body = models.TextField(blank=True, default="")
     image = models.ImageField(null=True, blank=True)
 
     author = models.ForeignKey(User, on_delete=models.SET_NULL, null=True, blank=True)
@@ -92,19 +62,10 @@ class Post(models.Model):
         default=timezone.now,
     )
 
-    __choices = [("N", _("News")), ("E", _("Event")), ("F", _("FetMeeting"))]
-    post_type = models.CharField(max_length=1, choices=__choices, editable=True)
-
-    class Status(models.TextChoices):
-        DRAFT = "10", _("DRAFT")
-        ONLY_INTERN = "15", _("ONLY_INTERN")
-        PUBLIC = "20", _("PUBLIC")
+    post_type = models.CharField(max_length=1, choices=PostType.choices, editable=True)
 
     status = models.CharField(
-        verbose_name="Status",
-        max_length=2,
-        choices=Status.choices,
-        default=Status.DRAFT,
+        verbose_name="Status", max_length=2, choices=Status.choices, default=Status.DRAFT
     )
 
     # post is pinned at main page
@@ -113,22 +74,18 @@ class Post(models.Model):
     # addional infos for events
     event_start = models.DateTimeField(verbose_name="Event Start", null=True, blank=True)
     event_end = models.DateTimeField(verbose_name="Event Ende", null=True, blank=True)
-    event_place = models.CharField(max_length=200, null=True, blank=True)
+    event_place = models.CharField(max_length=200, blank=True, default="")
 
     # protocol for fet meeting
     has_protocol = models.BooleanField(default=False)
     has_agenda = models.BooleanField(default=False)
-    protocol_key = models.CharField(max_length=200, null=True, blank=True)
-    agenda_key = models.CharField(max_length=200, null=True, blank=True)
+    protocol_key = models.CharField(max_length=200, blank=True, default="")
+    agenda_key = models.CharField(max_length=200, blank=True, default="")
 
     # TimeStamps
     date_modified = models.DateTimeField(auto_now=True)
     date_created = models.DateTimeField(auto_now_add=True)
 
-    # useless (-_-)
-    legacy_rubrik_id = models.IntegerField(null=True, blank=True)
-    imported_from = models.CharField(max_length=200, null=True, blank=True)
-
     # Managers
     objects = PostManager()
     articles = ArticleManager()
@@ -153,48 +110,45 @@ class Post(models.Model):
     def get_absolute_url(self):
         return reverse("posts:post", kwargs={"slug": self.slug})
 
+    # "#" for backward compatibility
+    _possible_empty_key_value = ["#", "", None]
+
     @property
     def agenda_html(self) -> str | None:
-        "Agenda HTML from Etherpad Pad"
-        if self.agenda_key in [None, "#"]:
+        if self.agenda_key in self._possible_empty_key_value:
             return None
 
         return ep_get_html(self.agenda_key)
 
+    @agenda_html.setter
+    def agenda_html(self, value: str) -> str | None:
+        if self.agenda_key in self._possible_empty_key_value:
+            self.create_agenda_key()
+
+        if not value or not self.agenda_key:
+            return None
+
+        ep_set_html(self.agenda_key, value)
+        logger.info("Set agenda etherpad '%s' for post '%s'.", self.agenda_key, self.slug)
+        return value
+
     @property
     def protocol_html(self) -> str | None:
-        "Protocol HTML from Etherpad Pad"
-        if self.protocol_key in [None, "#"]:
+        if self.protocol_key in self._possible_empty_key_value:
             return None
 
         return ep_get_html(self.protocol_key)
 
-    @agenda_html.setter
-    def agenda_html(self, value: str) -> str | None:
-        if self.agenda_key is None:
-            self.create_agenda_key()
-
-        if value is None or self.agenda_key in [None, "#"]:
-            return None
-
-        ep_set_html(self.agenda_key, value)
-        request_logger.info("Set agenda etherpad. Post: %s. Key: %s", self.slug, self.agenda_key)
-        return value
-
     @protocol_html.setter
     def protocol_html(self, value: str) -> str | None:
-        if self.protocol_key is None:
+        if self.protocol_key in self._possible_empty_key_value:
             self.create_protocol_key()
 
-        if value is None or self.protocol_key in [None, "#"]:
+        if not value or not self.protocol_key:
             return None
 
         ep_set_html(self.protocol_key, value)
-        request_logger.info(
-            "Set protocol etherpad. Post: %s. Key: %s",
-            self.slug,
-            self.protocol_key,
-        )
+        logger.info("Set protocol etherpad '%s' for post '%s'.", self.protocol_key, self.slug)
         return value
 
     _agenda_filename = None
@@ -202,15 +156,15 @@ class Post(models.Model):
 
     @property
     def agenda_url(self) -> str | None:
-        if self.has_agenda is not True:
+        if not self.has_agenda:
             self._agenda_url = None
             self._agenda_filename = None
             return self._agenda_url
 
-        if self._agenda_url is not None:
+        if self._agenda_url:
             return self._agenda_url
 
-        if (url := ep_get_url(self.agenda_key)) not in [None, "#"]:
+        if url := ep_get_url(self.agenda_key):
             self._agenda_url = url
             self._agenda_filename = self.slug + "-agenda.pdf"
         else:
@@ -221,7 +175,7 @@ class Post(models.Model):
 
     @property
     def agenda_filename(self) -> str | None:
-        if self._agenda_filename is not None:
+        if self._agenda_filename:
             return self._agenda_filename
 
         if self.has_agenda and self.agenda_url:
@@ -234,15 +188,15 @@ class Post(models.Model):
 
     @property
     def protocol_url(self) -> str | None:
-        if self.has_protocol is not True:
+        if not self.has_protocol:
             self._protocol_url = None
             self._protocol_filename = None
             return self._protocol_url
 
-        if self._protocol_url is not None:
+        if self._protocol_url:
             return self._protocol_url
 
-        if (url := ep_get_url(self.protocol_key)) not in [None, "#"]:
+        if url := ep_get_url(self.protocol_key):
             self._protocol_url = url
             self._protocol_filename = self.slug + "-protokoll.pdf"
         else:
@@ -253,7 +207,7 @@ class Post(models.Model):
 
     @property
     def protocol_filename(self) -> str | None:
-        if self._protocol_filename is not None:
+        if self._protocol_filename:
             return self._protocol_filename
 
         if self.has_protocol and self.protocol_url:
@@ -290,14 +244,9 @@ class Post(models.Model):
 
     @property
     def imageurl(self) -> str:
-        """
-        returns the url to the image
-        """
-        if self.image:
-            return self.image.url
-
-        # return default image
-        return settings.STATIC_URL + "img/FET-Logo-2014-quadrat.png"
+        return (
+            self.image.url if self.image else settings.STATIC_URL + "img/FET-Logo-2014-quadrat.png"
+        )
 
     def clean(self):
         if self.event_end and self.event_end < self.event_start:
@@ -307,7 +256,7 @@ class Post(models.Model):
 
     @property
     def published(self):
-        return self.status == self.Status.PUBLIC
+        return self.status == Status.PUBLIC
 
 
 class News(Post):
@@ -372,14 +321,17 @@ class FetMeeting(Event):
         if not self.slug:
             self.slug = self.__get_slug()
 
-        if ep_pad_exists(self.agenda_key) is not True or self.slug not in self.agenda_key:
+        if not ep_pad_exists(self.agenda_key) or self.agenda_key in self._possible_empty_key_value:
             self.create_agenda_key()
-            if self.agenda_key not in [None, "#"]:
+            if self.agenda_key:
                 self.has_agenda = True
 
-        if ep_pad_exists(self.protocol_key) is not True or self.slug not in self.protocol_key:
+        if (
+            not ep_pad_exists(self.protocol_key)
+            or self.protocol_key in self._possible_empty_key_value
+        ):
             self.create_protocol_key()
-            if self.protocol_key not in [None, "#"]:
+            if self.protocol_key:
                 self.has_protocol = True
 
         if not self.post_type:
@@ -393,7 +345,7 @@ class FetMeeting(Event):
             self.event_end = self.event_start + timedelta(hours=2)
 
         # set FET Meeting always public
-        self.status = self.Status.PUBLIC
+        self.status = Status.PUBLIC
 
         super().save(*args, **kwargs)
 
diff --git a/fet2020/posts/search_indexes.py b/fet2020/posts/search_indexes.py
index 7c04f575..667d28a6 100644
--- a/fet2020/posts/search_indexes.py
+++ b/fet2020/posts/search_indexes.py
@@ -17,7 +17,7 @@ class PostIndex(indexes.SearchIndex, indexes.Indexable):
         return Post
 
     def index_queryset(self, using=None):
-        return self.get_model().objects.date_sorted_list(public=False)
+        return self.get_model().objects.date_sorted(public=False)
 
     def prepare_date(self, obj):
         if obj.post_type == "N":
diff --git a/fet2020/posts/tests.py b/fet2020/posts/tests.py
index a33ba7d5..06277600 100644
--- a/fet2020/posts/tests.py
+++ b/fet2020/posts/tests.py
@@ -39,7 +39,7 @@ class PostTestCase(TestCase):
         post.event_start = timezone.now() - timedelta(1)
         post.save()
 
-        post_list = Post.objects.date_sorted_list(public=False)
+        post_list = Post.objects.date_sorted(public=False)
         self.assertEqual(post_list[0].title, "zukünftiges FET Fest")
         self.assertEqual(post_list[1].title, "Informationen zur ÖH Wahl")
         self.assertEqual(post_list[2].title, "vergangenes FET Fest")
diff --git a/fet2020/posts/views.py b/fet2020/posts/views.py
index d8a5b225..0f74063d 100644
--- a/fet2020/posts/views.py
+++ b/fet2020/posts/views.py
@@ -15,6 +15,7 @@ from documents.etherpadlib import add_ep_cookie
 from fet2020.utils import add_log_action
 from members.models import Member
 
+from .choices import PostType
 from .forms import (
     EventUpdateForm,
     FetMeetingCreateForm,
@@ -35,7 +36,7 @@ def index(request):
     if request.method == "POST":
         form = PostSearchForm(request.POST)
         if form.is_valid():
-            posts = Post.objects.date_filtered_list(
+            posts = Post.objects.date_filter(
                 public_only,
                 form.cleaned_data["year"],
                 form.cleaned_data["month"],
@@ -44,7 +45,7 @@ def index(request):
     else:
         # If no input, all posts are shown.
         form = PostSearchForm()
-        posts = Post.objects.date_filtered_list(public_only)
+        posts = Post.objects.date_filter(public_only)
 
     context = {
         "formset": form,
@@ -92,7 +93,7 @@ class PostDetailView(DetailView):
             try:
                 response = add_ep_cookie(request, response)
             except Exception as e:
-                logger.info("Etherpad Server doesn't work. Error: %s", e)
+                logger.info("Etherpad Server not working. Error: %s", e)
 
         return response
 
@@ -134,9 +135,9 @@ class PostDetailView(DetailView):
 
     def get_template_names(self):
         template_name = "posts/news/detail.html"
-        if self.object.post_type == "E":
+        if self.object.post_type == PostType.EVENT:
             template_name = "posts/event/detail.html"
-        elif self.object.post_type == "F":
+        elif self.object.post_type == PostType.FETMEETING:
             template_name = "posts/fetmeeting/detail.html"
 
         return template_name
@@ -145,7 +146,7 @@ class PostDetailView(DetailView):
         """
         Helper function for getting previous post
         """
-        posts = Post.objects.date_sorted_list(self.public_only).filter(
+        posts = Post.objects.date_sorted(self.public_only).filter(
             post_type=self.object.post_type,
         )
         qs = posts.filter(
@@ -165,7 +166,7 @@ class PostDetailView(DetailView):
         Helper function for getting next post
         """
         posts = (
-            Post.objects.date_sorted_list(self.public_only)
+            Post.objects.date_sorted(self.public_only)
             .filter(post_type=self.object.post_type)
             .reverse()
         )
@@ -187,9 +188,9 @@ class PostUpdateView(LoginRequiredMixin, UpdateView):
 
     def form_valid(self, form):
         model = "news"
-        if self.object.post_type == "E":
+        if self.object.post_type == PostType.EVENT:
             model = "event"
-        elif self.object.post_type == "F":
+        elif self.object.post_type == PostType.FETMEETING:
             model = "fetmeeting"
         add_log_action(self.request, form, "posts", model, False)
 
@@ -197,9 +198,9 @@ class PostUpdateView(LoginRequiredMixin, UpdateView):
 
     def get_form_class(self):
         form_class = NewsUpdateForm
-        if self.object.post_type == "E":
+        if self.object.post_type == PostType.EVENT:
             form_class = EventUpdateForm
-        elif self.object.post_type == "F":
+        elif self.object.post_type == PostType.FETMEETING:
             form_class = FetMeetingUpdateForm
 
         return form_class
@@ -229,9 +230,9 @@ class PostUpdateView(LoginRequiredMixin, UpdateView):
 
     def get_template_names(self):
         template_name = "posts/news/update.html"
-        if self.object.post_type == "E":
+        if self.object.post_type == PostType.EVENT:
             template_name = "posts/event/update.html"
-        elif self.object.post_type == "F":
+        elif self.object.post_type == PostType.FETMEETING:
             template_name = "posts/fetmeeting/update.html"
 
         return template_name
@@ -307,10 +308,8 @@ def show_pdf(request, html, filename):
     idx = html.index("<body>")
     html = html[:idx] + rendered + html[idx:]
 
-    pdf = render_to_pdf(html)
-
-    if not pdf:
-        raise Http404("can't create pdf file")
+    if not (pdf := render_to_pdf(html)):
+        raise Http404("can't create pdf file.")
 
     response = HttpResponse(pdf, content_type="application/pdf")