bofh/fet2020
8
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

code optimization

Browse Source
This commit is contained in:
Patrick Mayr
2025-02-02 12:42:20 +01:00
parent ace625a530
commit 2bc64cdc5b
10 changed files with 214 additions and 225 deletions
Download Patch File Download Diff File Expand all files Collapse all files

129
fet2020/documents/api.py
View File

@@ -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))

6
fet2020/documents/etherpadlib.py
View File

@@ -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),

2
fet2020/fet2020/views.py
View File

@@ -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

8
fet2020/posts/admin.py
View File

@@ -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)

13
fet2020/posts/choices.py Normal file
View File

@@ -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"

82
fet2020/posts/managers.py
View File

@@ -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

162
fet2020/posts/models.py
View File

@@ -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)

2
fet2020/posts/search_indexes.py
View File

@@ -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":

2
fet2020/posts/tests.py
View File

@@ -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")

33
fet2020/posts/views.py
View File

@@ -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")