from datetime import datetime
from typing import Any, Optional
from django.core.files import File
from django.core.validators import FileExtensionValidator, MaxValueValidator, MinValueValidator
from django.db import models
from django.urls import reverse
from django.utils import timezone
from django.utils.translation import gettext_lazy as _
import reversion
from calendarweek import CalendarWeek
from calendarweek.django import i18n_day_name_choices_lazy
from celery.result import allow_join_result
from celery.states import SUCCESS
from reversion.models import Revision, Version
from aleksis.core.mixins import ExtensibleModel, ExtensiblePolymorphicModel
from aleksis.core.models import DynamicRoute
from aleksis.core.util.pdf import generate_pdf_from_template
class PosterGroupDynamicRoute(DynamicRoute):
@classmethod
def get_dynamic_routes(cls):
poster_groups = PosterGroup.objects.all()
dynamic_routes = []
for poster_group in poster_groups:
dynamic_routes.append(cls.get_route_data(poster_group))
return dynamic_routes
@classmethod
def get_route_data(cls, instance):
dynamic_route = {}
dynamic_route["parent_route_name"] = ""
dynamic_route["route_path"] = reverse("poster_show_current", args=[instance.slug])
dynamic_route["route_name"] = f"resint.posterGroup.{instance.slug}"
dynamic_route["display_account_menu"] = False
dynamic_route["display_sidenav_menu"] = instance.show_in_menu
dynamic_route["menu_new_tab"] = True
dynamic_route["menu_title"] = instance.name
dynamic_route["menu_icon"] = "mdi-file-pdf-box"
dynamic_route["route_permission"] = "" if instance.public else "resint.view_poster_pdf_menu"
return dynamic_route
class PosterGroup(ExtensibleModel):
"""Group for time-based documents, called posters."""
slug = models.SlugField(
verbose_name=_("Slug used in URL name"),
help_text=_("If you use 'example', the filename will be 'example.pdf'."),
unique=True,
)
name = models.CharField(max_length=255, verbose_name=_("Name"), unique=True)
publishing_day = models.PositiveSmallIntegerField(
verbose_name=_("Publishing weekday"), choices=i18n_day_name_choices_lazy()
)
publishing_time = models.TimeField(verbose_name=_("Publishing time"))
default_pdf = models.FileField(
upload_to="default_posters/",
verbose_name=_("Default PDF"),
help_text=_("This PDF file will be shown if there is no current PDF."),
validators=[FileExtensionValidator(allowed_extensions=["pdf"])],
)
show_in_menu = models.BooleanField(default=True, verbose_name=_("Show in menu"))
public = models.BooleanField(default=False, verbose_name=_("Show for not logged-in users"))
class Meta:
verbose_name = _("Poster group")
verbose_name_plural = _("Poster groups")
permissions = [
("view_poster_of_group", _("Can view all posters of this group")),
("upload_poster_to_group", _("Can upload new posters to this group")),
("change_poster_of_group", _("Can change all posters of this group")),
("delete_poster_of_group", _("Can delete all posters of this group")),
]
def __str__(self) -> str:
return f"{self.name} ({self.publishing_day_name}, {self.publishing_time})"
@property
def publishing_day_name(self) -> str:
"""Return the full name of the publishing day (e. g. Monday)."""
return i18n_day_name_choices_lazy()[self.publishing_day][1]
@property
def filename(self) -> str:
"""Return the filename for the currently valid PDF file."""
return f"{self.slug}.pdf"
@property
def current_poster(self) -> Optional["Poster"]:
"""Get the currently valid poster."""
# Get current date with year and calendar week
current = timezone.datetime.now()
cw = CalendarWeek.from_date(current)
# Create datetime with the friday of the week and the toggle time
day = cw[self.publishing_day]
day_and_time = timezone.datetime.combine(day, self.publishing_time)
# Check whether to show the poster of the next week or the current week
if current > day_and_time:
cw += 1
# Look for matching PDF in DB
try:
obj = self.posters.get(year=cw.year, week=cw.week)
return obj
# Or show the default PDF
except Poster.DoesNotExist:
return None
def _get_current_year() -> int:
"""Get the current year."""
return timezone.now().year
calendar_weeks = [(cw, str(cw)) for cw in range(1, 53)]
class Poster(ExtensibleModel):
"""A time-based document."""
group = models.ForeignKey(
to=PosterGroup,
related_name="posters",
on_delete=models.CASCADE,
verbose_name=_("Poster group"),
)
week = models.PositiveSmallIntegerField(
verbose_name=_("Calendar week"),
validators=[MinValueValidator(1), MaxValueValidator(53)],
default=CalendarWeek.current_week,
choices=calendar_weeks,
)
year = models.PositiveSmallIntegerField(verbose_name=_("Year"), default=_get_current_year)
pdf = models.FileField(
upload_to="posters/",
verbose_name=_("PDF"),
validators=[FileExtensionValidator(allowed_extensions=["pdf"])],
)
class Meta:
constraints = [
models.UniqueConstraint(fields=["week", "year", "group"], name="unique_week_year_group")
]
verbose_name = _("Poster")
verbose_name_plural = _("Posters")
def __str__(self) -> str:
return f"{self.group.name}: {self.week}/{self.year}"
@property
def valid_from(self) -> datetime:
"""Return the time this poster is valid from."""
cw = CalendarWeek(week=self.week, year=self.year) - 1
day = cw[self.group.publishing_day]
return timezone.datetime.combine(day, self.group.publishing_time)
@property
def valid_to(self) -> datetime:
"""Return the time this poster is valid to."""
cw = CalendarWeek(week=self.week, year=self.year)
day = cw[self.group.publishing_day]
return timezone.datetime.combine(day, self.group.publishing_time)
class LiveDocument(ExtensiblePolymorphicModel):
"""Model for periodically/automatically updated files."""
SCOPE_PREFIX = "live_document_pdf"
template = None
slug = models.SlugField(
verbose_name=_("Slug"),
help_text=_("This will be used for the name of the current PDF file."),
)
name = models.CharField(max_length=255, verbose_name=_("Name"))
public = models.BooleanField(default=False, verbose_name=_("Show for not logged-in users"))
current_file = models.FileField(
upload_to="live_documents/",
blank=True,
verbose_name=_("Current file"),
editable=False,
)
last_update_triggered_manually = models.BooleanField(
default=False, verbose_name=_("Was the last update triggered manually?"), editable=False
)
class Meta:
verbose_name = _("Live document")
verbose_name_plural = _("Live documents")
def __str__(self) -> str:
return self.name
def save(self, *args, **kwargs):
with reversion.create_revision():
super().save(*args, **kwargs)
@property
def last_version(self) -> Optional[Revision]:
"""Get django-reversion version of last file update."""
versions = Version.objects.get_for_object(self).order_by("revision__date_created")
if versions.exists():
return versions.last()
return None
@property
def last_update(self) -> Optional[datetime]:
"""Get datetime of last file update."""
last_version = self.last_version
if last_version:
return last_version.revision.date_created
return None
def get_current_file(self) -> Optional[File]:
"""Get current file."""
if not self.current_file:
self.update()
return self.current_file
@property
def filename(self) -> str:
"""Get the filename without path of the PDF file."""
return f"{self.slug}.pdf"
@property
def scope(self) -> str:
"""Return OAuth2 scope name to access PDF file via API."""
return f"{self.SCOPE_PREFIX}_{self.slug}"
def get_context_data(self) -> dict[str, Any]:
"""Get context to pass to the PDF template."""
return {}
def update(self, triggered_manually: bool = True):
"""Update the file with a new version.
Has to be implemented by subclasses.
"""
if not self.template:
raise NotImplementedError("Subclasses of LiveDocument must implement update()")
file_object, result = generate_pdf_from_template(self.template, self.get_context_data())
with allow_join_result():
result.wait()
file_object.refresh_from_db()
if result.status == SUCCESS and file_object.file:
self.last_update_triggered_manually = triggered_manually
self.current_file.save(self.filename, file_object.file.file)
self.save()