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 = f.read()
api_key = api_key.rstrip() api_key = api_key.rstrip()
if api_key == "": if not api_key:
logger.info("API Key is missing. Path: %s", api_key_path) logger.info("API Key is missing. Path: %s", api_key_path)
return None return None
@@ -56,97 +56,114 @@ def get_ep_group(ep_group_name: str = "fet") -> dict[str, str]:
return ep_group 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. """Check if pad exists.
Parameters Parameters
---------- ----------
pad_id : str | None pad_id : str
Id of pad that is checked if it exists. Id of pad that is checked if it exists.
Returns Returns
------- -------
bool | None bool
- True: Pad exists. - True: Pad exists.
- False: Pad doesn't exist. - False: Pad not found.
- None: There is no pad id or no connection to etherpad server. - None: There is no pad id or no connection to etherpad server.
""" """
if pad_id is None: if not pad_id:
return None return None
if (ep_c := get_ep_client()) is None: if not (ep_c := get_ep_client()):
return None return None
if (ep_group := get_ep_group()) is None: if not (ep_group := get_ep_group()):
return None return None
lists = ep_c.listPads(groupID=ep_group["groupID"]) lists = ep_c.listPads(groupID=ep_group["groupID"])
if any(pad_id in s for s in lists["padIDs"]): 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 return True
logger.info("Etherpad doesn't exist. Pad: %s", pad_id) logger.info("Etherpad '%s' not found.", pad_id)
return False 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. if not pad_id:
Return a pad_id if new pad is created. Otherwise None (when the padID exists already).
"""
if pad_id is None:
return None return None
if (ep_c := get_ep_client()) is None: if not (ep_c := get_ep_client()):
return 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) 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:
return None return None
if ep_pad_exists(pad_id): if ep_pad_exists(pad_id):
return ep_c.getHTML(padID=ep_group["groupID"] + "$" + pad_id)["html"] logger.info("Can't create new etherpad '%s' because it already exists.", pad_id)
return ""
def ep_set_html(pad_id: str | None, html: str):
if (ep_c := get_ep_client()) is None:
return None 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 return None
if ep_pad_exists(pad_id): if not (ep_c := get_ep_client()):
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:
return None return None
if ep_pad_exists(pad_id): if not (ep_group := get_ep_group()):
return urljoin( return None
settings.ETHERPAD_CLIENT["exturl"],
"p/" + ep_group["groupID"] + "$" + str(pad_id),
)
return "#" if not ep_pad_exists(pad_id):
return None
return ep_c.getHTML(padID=ep_group["groupID"] + "$" + pad_id)["html"]
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 @ep_authenticated_user
def _create_ep_session(request, expires): def _create_ep_session(request, expires):
if (ep_c := get_ep_client()) is None: if not (ep_c := get_ep_client()):
return None return None
if (ep_group := get_ep_group()) is None: if not (ep_group := get_ep_group()):
return None, None return None
author = ep_c.createAuthorIfNotExistsFor( author = ep_c.createAuthorIfNotExistsFor(
name=str(request.user), 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): 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. # A maximum of 5 posts should be displayed on the startpage.
post_count = 5 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): def make_fetmeeting(self, request, queryset):
qs = self.get_queryset(request).filter(id=request.POST["_selected_action"]).first() 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 := ep_create_new_pad(qs.slug + "-agenda")):
if not agenda_key:
self.message_user( self.message_user(
request, request,
"Das Agenda konnte nicht erstellt werden.", "Das Agenda konnte nicht erstellt werden.",
@@ -19,8 +18,7 @@ def make_fetmeeting(self, request, queryset):
) )
return return
protocol_key = ep_create_new_pad(qs.slug + "-protocol") if not (protocol_key := ep_create_new_pad(qs.slug + "-protocol")):
if not protocol_key:
self.message_user( self.message_user(
request, request,
"Das Protokoll konnte nicht erstellt werden.", "Das Protokoll konnte nicht erstellt werden.",
@@ -79,7 +77,7 @@ class PostAdmin(admin.ModelAdmin):
) )
def save_model(self, request, obj, form, change): def save_model(self, request, obj, form, change):
if obj.author is None: if not obj.author:
obj.author = request.user obj.author = request.user
super().save_model(request, obj, form, change) 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 import models
from django.db.models import Case, Q, When from django.db.models import Case, Q, When
from django.utils import timezone
from .choices import PostType, Status
class PublishedManager(models.Manager): class PublishedManager(models.Manager):
@@ -10,33 +11,36 @@ class PublishedManager(models.Manager):
""" """
publish all posts with status 'PUBLIC' publish all posts with status 'PUBLIC'
""" """
qs = self.get_queryset().filter(status="20") if public else self.get_queryset() return self.get_queryset().filter(status=Status.PUBLIC) if public else self.get_queryset()
return qs
def published_all(self, public=True): def published_all(self, public=True):
""" """
publish all posts with status 'PUBLIC' and 'ONLY_INTERN' publish all posts with status 'PUBLIC' and 'ONLY_INTERN'
""" """
qs = self.get_queryset().filter(~Q(status="10")) if public else self.get_queryset() return (
return qs self.get_queryset().filter(~Q(status=Status.DRAFT)) if public else self.get_queryset()
)
class PostManager(PublishedManager, models.Manager): class PostManager(PublishedManager, models.Manager):
def get_queryset(self): def get_queryset(self):
qs = super().get_queryset() qs = (
qs = qs.annotate( super()
date=Case( .get_queryset()
When(post_type="N", then="public_date"), .annotate(
When(post_type="E", then="event_start__date"), date=Case(
When(post_type="F", then="event_start__date"), 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") return qs.order_by("-date", "-id")
def date_sorted_list(self, public=True): def date_sorted(self, public=True):
return self.published(public) return self.published(public)
def date_filtered_list( def date_filter(
self, self,
public=True, public=True,
year=None, year=None,
@@ -46,7 +50,7 @@ class PostManager(PublishedManager, models.Manager):
qs_filter = Q() qs_filter = Q()
if fet_meeting_only: if fet_meeting_only:
qs_filter &= Q(post_type="F") qs_filter &= Q(post_type=PostType.FETMEETING)
if year: if year:
qs_filter &= Q(date__year=year) qs_filter &= Q(date__year=year)
@@ -63,16 +67,16 @@ class ArticleManager(PublishedManager, models.Manager):
""" """
def get_queryset(self): 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( qs = qs.annotate(
date=Case( date=Case(
When(post_type="N", then="public_date"), When(post_type=PostType.NEWS, then="public_date"),
When(post_type="E", then="event_start__date"), When(post_type=PostType.EVENT, then="event_start__date"),
), ),
) )
return qs.order_by("-date", "-id") return qs.order_by("-date", "-id")
def date_sorted_list(self, public=True): def date_sorted(self, public=True):
return self.published(public) return self.published(public)
def pinned(self, public=True): def pinned(self, public=True):
@@ -95,10 +99,12 @@ class ArticleManager(PublishedManager, models.Manager):
return ( return (
self.published(public) self.published(public)
.filter(is_pinned=True)
.filter( .filter(
(Q(post_type="N") & Q(public_date__gt=post_date)) Q(is_pinned=True)
| (Q(post_type="E") & Q(event_end__date__gt=event_date)), & (
(Q(post_type=PostType.NEWS) & Q(public_date__gt=post_date))
| (Q(post_type=PostType.EVENT) & Q(event_end__date__gt=event_date))
)
) )
.first() .first()
) )
@@ -110,10 +116,10 @@ class NewsManager(PublishedManager, models.Manager):
""" """
def get_queryset(self): def get_queryset(self):
qs = super().get_queryset().filter(post_type="N") qs = super().get_queryset().filter(post_type=PostType.NEWS)
qs = qs.annotate( qs = qs.annotate(
date=Case( date=Case(
When(post_type="N", then="public_date"), When(post_type=PostType.NEWS, then="public_date"),
), ),
) )
return qs.order_by("-date") return qs.order_by("-date")
@@ -125,17 +131,21 @@ class AllEventManager(PublishedManager, models.Manager):
""" """
def get_queryset(self): 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( qs = qs.annotate(
date=Case( date=Case(
When(post_type="E", then="event_start__date"), When(post_type=PostType.EVENT, then="event_start__date"),
When(post_type="F", then="event_start__date"), When(post_type=PostType.FETMEETING, then="event_start__date"),
), ),
) )
return qs.order_by("-date") return qs.order_by("-date")
def future_events(self, public=True): 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) qs = self.published(public).filter(event_start__gt=date_today)
return qs.reverse() return qs.reverse()
@@ -147,21 +157,21 @@ class EventManager(PublishedManager, models.Manager):
""" """
def get_queryset(self): def get_queryset(self):
qs = super().get_queryset().filter(post_type="E") qs = super().get_queryset().filter(post_type=PostType.EVENT)
qs = qs.annotate( qs = qs.annotate(
date=Case( date=Case(
When(post_type="E", then="event_start__date"), When(post_type=PostType.EVENT, then="event_start__date"),
), ),
) )
return qs.order_by("-date") return qs.order_by("-date")
def future_events(self, public=True): 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) qs = self.published(public).filter(event_start__gt=date_today)
return qs.reverse() return qs.reverse()
def past_events(self, public=True): 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) qs = self.published(public).filter(event_start__lt=date_today)
return qs return qs
@@ -172,20 +182,20 @@ class FetMeetingManager(PublishedManager, models.Manager):
""" """
def get_queryset(self): def get_queryset(self):
qs = super().get_queryset().filter(post_type="F") qs = super().get_queryset().filter(post_type=PostType.FETMEETING)
qs = qs.annotate( qs = qs.annotate(
date=Case( date=Case(
When(post_type="F", then="event_start__date"), When(post_type=PostType.FETMEETING, then="event_start__date"),
), ),
) )
return qs.order_by("-date") return qs.order_by("-date")
def future_events(self): def future_events(self):
date_today = timezone.now() date_today = datetime.date.today()
qs = self.published().filter(event_start__gt=date_today) qs = self.published().filter(event_start__gt=date_today)
return qs.reverse() return qs.reverse()
def past_events(self): def past_events(self):
date_today = timezone.now() date_today = datetime.date.today()
qs = self.published().filter(event_start__lt=date_today) qs = self.published().filter(event_start__lt=date_today)
return qs 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.urls import reverse
from django.utils import timezone from django.utils import timezone
from django.utils.text import slugify from django.utils.text import slugify
from django.utils.translation import gettext_lazy as _
from taggit.managers import TaggableManager from taggit.managers import TaggableManager
from core.models import CustomFlatPage from core.models import CustomFlatPage
from documents.api import ( from documents.api import ep_create_new_pad, ep_get_html, ep_get_url, ep_pad_exists, ep_set_html
ep_create_new_pad,
ep_get_html,
ep_get_url,
ep_pad_exists,
ep_set_html,
)
from .choices import PostType, Status
from .managers import ( from .managers import (
AllEventManager, AllEventManager,
ArticleManager, ArticleManager,
@@ -30,44 +24,21 @@ from .managers import (
) )
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)
request_logger = logging.getLogger("django.request")
def create_pad_for_post(slug, item="agenda"): def create_pad_for_post(slug, item="agenda"):
""" logger.info("Pad-Type: %s", item)
Create a Etherpad pad.
Return a Etherpad key.
"""
logger.info(f"Pad-Type: {item}")
pad_id = slug + "-" + item pad_id = slug + "-" + item
if ep_create_new_pad(pad_id): if not ep_create_new_pad(pad_id):
# Set template into the newly created pad if it exists. return ""
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}")
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 "#" return pad_id
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"
class Post(models.Model): class Post(models.Model):
@@ -75,13 +46,12 @@ class Post(models.Model):
legacy_id = models.IntegerField(null=True, blank=True) legacy_id = models.IntegerField(null=True, blank=True)
title = models.CharField(verbose_name="Titel", max_length=200) 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) 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) 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) image = models.ImageField(null=True, blank=True)
author = models.ForeignKey(User, on_delete=models.SET_NULL, 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, default=timezone.now,
) )
__choices = [("N", _("News")), ("E", _("Event")), ("F", _("FetMeeting"))] post_type = models.CharField(max_length=1, choices=PostType.choices, editable=True)
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")
status = models.CharField( status = models.CharField(
verbose_name="Status", verbose_name="Status", max_length=2, choices=Status.choices, default=Status.DRAFT
max_length=2,
choices=Status.choices,
default=Status.DRAFT,
) )
# post is pinned at main page # post is pinned at main page
@@ -113,22 +74,18 @@ class Post(models.Model):
# addional infos for events # addional infos for events
event_start = models.DateTimeField(verbose_name="Event Start", null=True, blank=True) 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_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 # protocol for fet meeting
has_protocol = models.BooleanField(default=False) has_protocol = models.BooleanField(default=False)
has_agenda = models.BooleanField(default=False) has_agenda = models.BooleanField(default=False)
protocol_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, null=True, blank=True) agenda_key = models.CharField(max_length=200, blank=True, default="")
# TimeStamps # TimeStamps
date_modified = models.DateTimeField(auto_now=True) date_modified = models.DateTimeField(auto_now=True)
date_created = models.DateTimeField(auto_now_add=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 # Managers
objects = PostManager() objects = PostManager()
articles = ArticleManager() articles = ArticleManager()
@@ -153,48 +110,45 @@ class Post(models.Model):
def get_absolute_url(self): def get_absolute_url(self):
return reverse("posts:post", kwargs={"slug": self.slug}) return reverse("posts:post", kwargs={"slug": self.slug})
# "#" for backward compatibility
_possible_empty_key_value = ["#", "", None]
@property @property
def agenda_html(self) -> str | None: def agenda_html(self) -> str | None:
"Agenda HTML from Etherpad Pad" if self.agenda_key in self._possible_empty_key_value:
if self.agenda_key in [None, "#"]:
return None return None
return ep_get_html(self.agenda_key) 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 @property
def protocol_html(self) -> str | None: def protocol_html(self) -> str | None:
"Protocol HTML from Etherpad Pad" if self.protocol_key in self._possible_empty_key_value:
if self.protocol_key in [None, "#"]:
return None return None
return ep_get_html(self.protocol_key) 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 @protocol_html.setter
def protocol_html(self, value: str) -> str | None: 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() self.create_protocol_key()
if value is None or self.protocol_key in [None, "#"]: if not value or not self.protocol_key:
return None return None
ep_set_html(self.protocol_key, value) ep_set_html(self.protocol_key, value)
request_logger.info( logger.info("Set protocol etherpad '%s' for post '%s'.", self.protocol_key, self.slug)
"Set protocol etherpad. Post: %s. Key: %s",
self.slug,
self.protocol_key,
)
return value return value
_agenda_filename = None _agenda_filename = None
@@ -202,15 +156,15 @@ class Post(models.Model):
@property @property
def agenda_url(self) -> str | None: def agenda_url(self) -> str | None:
if self.has_agenda is not True: if not self.has_agenda:
self._agenda_url = None self._agenda_url = None
self._agenda_filename = None self._agenda_filename = None
return self._agenda_url return self._agenda_url
if self._agenda_url is not None: if self._agenda_url:
return 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_url = url
self._agenda_filename = self.slug + "-agenda.pdf" self._agenda_filename = self.slug + "-agenda.pdf"
else: else:
@@ -221,7 +175,7 @@ class Post(models.Model):
@property @property
def agenda_filename(self) -> str | None: def agenda_filename(self) -> str | None:
if self._agenda_filename is not None: if self._agenda_filename:
return self._agenda_filename return self._agenda_filename
if self.has_agenda and self.agenda_url: if self.has_agenda and self.agenda_url:
@@ -234,15 +188,15 @@ class Post(models.Model):
@property @property
def protocol_url(self) -> str | None: def protocol_url(self) -> str | None:
if self.has_protocol is not True: if not self.has_protocol:
self._protocol_url = None self._protocol_url = None
self._protocol_filename = None self._protocol_filename = None
return self._protocol_url return self._protocol_url
if self._protocol_url is not None: if self._protocol_url:
return 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_url = url
self._protocol_filename = self.slug + "-protokoll.pdf" self._protocol_filename = self.slug + "-protokoll.pdf"
else: else:
@@ -253,7 +207,7 @@ class Post(models.Model):
@property @property
def protocol_filename(self) -> str | None: def protocol_filename(self) -> str | None:
if self._protocol_filename is not None: if self._protocol_filename:
return self._protocol_filename return self._protocol_filename
if self.has_protocol and self.protocol_url: if self.has_protocol and self.protocol_url:
@@ -290,14 +244,9 @@ class Post(models.Model):
@property @property
def imageurl(self) -> str: def imageurl(self) -> str:
""" return (
returns the url to the image self.image.url if self.image else settings.STATIC_URL + "img/FET-Logo-2014-quadrat.png"
""" )
if self.image:
return self.image.url
# return default image
return settings.STATIC_URL + "img/FET-Logo-2014-quadrat.png"
def clean(self): def clean(self):
if self.event_end and self.event_end < self.event_start: if self.event_end and self.event_end < self.event_start:
@@ -307,7 +256,7 @@ class Post(models.Model):
@property @property
def published(self): def published(self):
return self.status == self.Status.PUBLIC return self.status == Status.PUBLIC
class News(Post): class News(Post):
@@ -372,14 +321,17 @@ class FetMeeting(Event):
if not self.slug: if not self.slug:
self.slug = self.__get_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() self.create_agenda_key()
if self.agenda_key not in [None, "#"]: if self.agenda_key:
self.has_agenda = True 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() self.create_protocol_key()
if self.protocol_key not in [None, "#"]: if self.protocol_key:
self.has_protocol = True self.has_protocol = True
if not self.post_type: if not self.post_type:
@@ -393,7 +345,7 @@ class FetMeeting(Event):
self.event_end = self.event_start + timedelta(hours=2) self.event_end = self.event_start + timedelta(hours=2)
# set FET Meeting always public # set FET Meeting always public
self.status = self.Status.PUBLIC self.status = Status.PUBLIC
super().save(*args, **kwargs) super().save(*args, **kwargs)

2
fet2020/posts/search_indexes.py
View File

@@ -17,7 +17,7 @@ class PostIndex(indexes.SearchIndex, indexes.Indexable):
return Post return Post
def index_queryset(self, using=None): 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): def prepare_date(self, obj):
if obj.post_type == "N": 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.event_start = timezone.now() - timedelta(1)
post.save() 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[0].title, "zukünftiges FET Fest")
self.assertEqual(post_list[1].title, "Informationen zur ÖH Wahl") self.assertEqual(post_list[1].title, "Informationen zur ÖH Wahl")
self.assertEqual(post_list[2].title, "vergangenes FET Fest") 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 fet2020.utils import add_log_action
from members.models import Member from members.models import Member
from .choices import PostType
from .forms import ( from .forms import (
EventUpdateForm, EventUpdateForm,
FetMeetingCreateForm, FetMeetingCreateForm,
@@ -35,7 +36,7 @@ def index(request):
if request.method == "POST": if request.method == "POST":
form = PostSearchForm(request.POST) form = PostSearchForm(request.POST)
if form.is_valid(): if form.is_valid():
posts = Post.objects.date_filtered_list( posts = Post.objects.date_filter(
public_only, public_only,
form.cleaned_data["year"], form.cleaned_data["year"],
form.cleaned_data["month"], form.cleaned_data["month"],
@@ -44,7 +45,7 @@ def index(request):
else: else:
# If no input, all posts are shown. # If no input, all posts are shown.
form = PostSearchForm() form = PostSearchForm()
posts = Post.objects.date_filtered_list(public_only) posts = Post.objects.date_filter(public_only)
context = { context = {
"formset": form, "formset": form,
@@ -92,7 +93,7 @@ class PostDetailView(DetailView):
try: try:
response = add_ep_cookie(request, response) response = add_ep_cookie(request, response)
except Exception as e: 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 return response
@@ -134,9 +135,9 @@ class PostDetailView(DetailView):
def get_template_names(self): def get_template_names(self):
template_name = "posts/news/detail.html" 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" 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" template_name = "posts/fetmeeting/detail.html"
return template_name return template_name
@@ -145,7 +146,7 @@ class PostDetailView(DetailView):
""" """
Helper function for getting previous post 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, post_type=self.object.post_type,
) )
qs = posts.filter( qs = posts.filter(
@@ -165,7 +166,7 @@ class PostDetailView(DetailView):
Helper function for getting next post Helper function for getting next post
""" """
posts = ( posts = (
Post.objects.date_sorted_list(self.public_only) Post.objects.date_sorted(self.public_only)
.filter(post_type=self.object.post_type) .filter(post_type=self.object.post_type)
.reverse() .reverse()
) )
@@ -187,9 +188,9 @@ class PostUpdateView(LoginRequiredMixin, UpdateView):
def form_valid(self, form): def form_valid(self, form):
model = "news" model = "news"
if self.object.post_type == "E": if self.object.post_type == PostType.EVENT:
model = "event" model = "event"
elif self.object.post_type == "F": elif self.object.post_type == PostType.FETMEETING:
model = "fetmeeting" model = "fetmeeting"
add_log_action(self.request, form, "posts", model, False) add_log_action(self.request, form, "posts", model, False)
@@ -197,9 +198,9 @@ class PostUpdateView(LoginRequiredMixin, UpdateView):
def get_form_class(self): def get_form_class(self):
form_class = NewsUpdateForm form_class = NewsUpdateForm
if self.object.post_type == "E": if self.object.post_type == PostType.EVENT:
form_class = EventUpdateForm form_class = EventUpdateForm
elif self.object.post_type == "F": elif self.object.post_type == PostType.FETMEETING:
form_class = FetMeetingUpdateForm form_class = FetMeetingUpdateForm
return form_class return form_class
@@ -229,9 +230,9 @@ class PostUpdateView(LoginRequiredMixin, UpdateView):
def get_template_names(self): def get_template_names(self):
template_name = "posts/news/update.html" 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" 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" template_name = "posts/fetmeeting/update.html"
return template_name return template_name
@@ -307,10 +308,8 @@ def show_pdf(request, html, filename):
idx = html.index("<body>") idx = html.index("<body>")
html = html[:idx] + rendered + html[idx:] html = html[:idx] + rendered + html[idx:]
pdf = render_to_pdf(html) if not (pdf := render_to_pdf(html)):
raise Http404("can't create pdf file.")
if not pdf:
raise Http404("can't create pdf file")
response = HttpResponse(pdf, content_type="application/pdf") response = HttpResponse(pdf, content_type="application/pdf")