fet2020/fet2020/posts/managers.py

import calendar
import datetime

from django.db import models
from django.db.models import Case, Q, When
from django.utils import timezone

from .choices import PostType, Status


class PublishedManager(models.Manager):
    def published(self, public=True):
        """
        publish all posts with status 'PUBLIC'
        """
        return self.get_queryset().filter(status=Status.PUBLIC) if public else self.get_queryset()

    def published_all(self, public=True):
        """
        publish all posts with status 'PUBLIC' and 'ONLY_INTERN'
        """
        return (
            self.get_queryset().filter(~Q(status=Status.DRAFT)) if public else self.get_queryset()
        )


class PostManager(PublishedManager, models.Manager):
    def get_queryset(self):
        qs = (
            super()
            .get_queryset()
            .annotate(
                date=Case(
                    When(post_type=PostType.NEWS, then="public_date"),
                    When(post_type=PostType.EVENT, then="event_start__date"),
                    When(post_type=PostType.FETMEETING, then="event_start__date"),
                ),
            )
        )
        return qs.order_by("-date", "-id")

    def date_sorted(self, public=True):
        return self.published(public)

    def date_filter(
        self,
        public=True,
        year=None,
        month=None,
        fet_meeting_only=None,
    ):
        qs_filter = Q()

        if fet_meeting_only:
            qs_filter &= Q(post_type=PostType.FETMEETING)

        if year:
            qs_filter &= Q(date__year=year)
            if month:
                qs_filter &= Q(date__month=month)

        return self.published(public).filter(qs_filter)


class ArticleManager(PublishedManager, models.Manager):
    """
    Provide a query set only for "Article"
    regular fet meetings should not be contained in the news stream
    """

    def get_queryset(self):
        qs = super().get_queryset().filter(Q(post_type=PostType.NEWS) | Q(post_type=PostType.EVENT))
        qs = qs.annotate(
            date=Case(
                When(post_type=PostType.NEWS, then="public_date"),
                When(post_type=PostType.EVENT, then="event_start__date"),
            ),
        )
        return qs.order_by("-date", "-id")

    def date_sorted(self, public=True):
        return self.published(public)

    def pinned(self, public=True):
        # Get date for pinned news that is max 1 month old.
        post_date = timezone.now().date()
        _day = post_date.day
        _month = post_date.month
        _year = post_date.year

        if _month != 1:
            _month -= 1
        else:
            # If the current month is January, you get the date from December of previous year.
            _month = 12
            _year -= 1

        # Clamp day to last day of target month (handles 30/31 and Feb)
        last_day = calendar.monthrange(_year, _month)[1]
        safe_day = min(_day, last_day)

        post_date = post_date.replace(year=_year, month=_month, day=safe_day)

        # Get date for event posts that is max 1 day old.
        event_date = timezone.now().date() - datetime.timedelta(1)

        return (
            self.published(public)
            .filter(
                Q(is_pinned=True)
                & (
                    (Q(post_type=PostType.NEWS) & Q(public_date__gt=post_date))
                    | (Q(post_type=PostType.EVENT) & Q(event_end__date__gt=event_date))
                )
            )
            .first()
        )


class NewsManager(PublishedManager, models.Manager):
    """
    Provide a query set only for "News"
    """

    def get_queryset(self):
        qs = super().get_queryset().filter(post_type=PostType.NEWS)
        qs = qs.annotate(
            date=Case(
                When(post_type=PostType.NEWS, then="public_date"),
            ),
        )
        return qs.order_by("-date")


class AllEventManager(PublishedManager, models.Manager):
    """
    Provide a query set for all events ("Event" and "Fet Meeting")
    """

    def get_queryset(self):
        qs = (
            super()
            .get_queryset()
            .filter(Q(post_type=PostType.EVENT) | Q(post_type=PostType.FETMEETING))
        )
        qs = qs.annotate(
            date=Case(
                When(post_type=PostType.EVENT, then="event_start__date"),
                When(post_type=PostType.FETMEETING, then="event_start__date"),
            ),
        )
        return qs.order_by("-date")

    def future_events(self, public=True):
        date_today = timezone.now().date()
        qs = self.published(public).filter(event_start__gt=date_today)
        return qs.reverse()


class EventManager(PublishedManager, models.Manager):
    """
    Provide a query set only for "Events"
    regular fet meetings should not be contained in the news stream
    """

    def get_queryset(self):
        qs = super().get_queryset().filter(post_type=PostType.EVENT)
        qs = qs.annotate(
            date=Case(
                When(post_type=PostType.EVENT, then="event_start__date"),
            ),
        )
        return qs.order_by("-date")

    def future_events(self, public=True):
        date_today = timezone.now().date()
        qs = self.published(public).filter(event_start__gt=date_today)
        return qs.reverse()

    def past_events(self, public=True):
        date_today = timezone.now().date()
        qs = self.published(public).filter(event_start__lt=date_today)
        return qs


class FetMeetingManager(PublishedManager, models.Manager):
    """
    Provide a query set only for "Fet Meeting"
    """

    def get_queryset(self):
        qs = super().get_queryset().filter(post_type=PostType.FETMEETING)
        qs = qs.annotate(
            date=Case(
                When(post_type=PostType.FETMEETING, then="event_start__date"),
            ),
        )
        return qs.order_by("-date")

    def future_events(self):
        date_today = timezone.now().date()
        qs = self.published().filter(event_start__gt=date_today)
        return qs.reverse()

    def past_events(self):
        date_today = timezone.now().date()
        qs = self.published().filter(event_start__lt=date_today)
        return qs