fet2020/fet2020/posts/managers.py

import datetime

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


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

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


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"),
            )
        )
        return qs.order_by("-date")

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

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

        if fet_meeting_only:
            qs_filter &= Q(post_type="F")

        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="N") | Q(post_type="E"))
        qs = qs.annotate(
            date=Case(
                When(post_type="N", then="public_date"),
                When(post_type="E", then="event_start__date"),
            )
        )
        return qs.order_by("-date")

    def date_sorted_list(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 = datetime.date.today()
        __month = post_date.month
        __year = post_date.year

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

        post_date = post_date.replace(year=__year, month=__month)

        # Get date for event posts that is max 7 days old.
        event_date = datetime.date.today() - datetime.timedelta(7)

        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))
            )
            .first()
        )


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

    def get_queryset(self):
        qs = super().get_queryset().filter(post_type="N")
        qs = qs.annotate(
            date=Case(
                When(post_type="N", 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="E") | Q(post_type="F"))
        qs = qs.annotate(
            date=Case(
                When(post_type="E", then="event_start__date"),
                When(post_type="F", then="event_start__date"),
            )
        )
        return qs.order_by("-date")

    def future_events(self, public=True):
        date_today = timezone.now()
        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="E")
        qs = qs.annotate(
            date=Case(
                When(post_type="E", then="event_start__date"),
            )
        )
        return qs.order_by("-date")

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

    def past_events(self, public=True):
        date_today = timezone.now()
        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="F")
        qs = qs.annotate(
            date=Case(
                When(post_type="F", then="event_start__date"),
            )
        )
        return qs.order_by("-date")

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

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