fet2020/fet2020/posts/managers.py

from django.db import models
from django.db.models import Q
from django.utils import timezone

from datetime import timedelta


class PostManager(models.Manager):
    def get_queryset(self):
        return super().get_queryset().order_by("-public_date")

    def get_visible_articles(self):
        return self.get_queryset().filter(is_hidden=False)

    def get_date_sorted_list(self):
        post_list = []
        for post in self.get_visible_articles():
            if post.post_type != "N":
                post_list.append((post, post.event_start.date()))
            else:
                post_list.append((post, post.public_date))

        result = sorted(post_list, key=lambda x: x[1], reverse=True)
        posts = [x[0] for x in result]

        return posts

    def get_date_filtered_list(self, year=None, month=None, fet_meeting_only=None):
        post_list = []

        if not fet_meeting_only:
            posts = self.get_visible_articles().filter(~Q(post_type="N"))
        else:
            posts = self.get_visible_articles().filter(post_type="F")

        if year:
            posts = posts.filter(event_start__year=year)
            if month:
                posts = posts.filter(event_start__month=month)

        for post in posts:
            post_list.append((post, post.event_start.date()))

        if not fet_meeting_only:
            posts = self.get_visible_articles().filter(post_type="N")

            if year:
                posts = posts.filter(public_date__year=year)
                if month:
                    posts = posts.filter(public_date__month=month)

            for post in posts:
                post_list.append((post, post.public_date))

        result = sorted(post_list, key=lambda x: x[1], reverse=True)
        posts = [x[0] for x in result]

        return posts

    def get_last_months_posts(self):
        date_today = timezone.now().date()
        return self.get_visible_articles().filter(
            public_date__gt=date_today - timedelta(days=365)
        )

    def get_all_posts_with_date(self):
        return (
            self.get_queryset()
            .filter(Q(event_start__isnull=False) & Q(event_end__isnull=False))
            .order_by("-event_start")
        )


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

    def get_queryset(self):
        return (
            super()
            .get_queryset()
            .filter(Q(post_type="E") | Q(post_type="N"))
            .order_by("-public_date")
        )

    def get_visible_articles(self):
        return self.get_queryset().filter(is_hidden=False)

    def get_date_sorted_list(self):
        post_list = []
        for post in self.get_visible_articles():
            if post.post_type != "N":
                post_list.append((post, post.event_start.date()))
            else:
                post_list.append((post, post.public_date))

        result = sorted(post_list, key=lambda x: x[1], reverse=True)
        posts = [x[0] for x in result]

        return posts

    def get_pinned_article(self):
        return self.get_visible_articles().filter(is_pinned=True).first()


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

    def get_queryset(self):
        return super().get_queryset().filter(post_type="N").order_by("-public_date")

    def get_visible_articles(self):
        return self.get_queryset().filter(is_hidden=False)


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

    def get_queryset(self):
        return super().get_queryset().filter(Q(post_type="E") | Q(post_type="F"))

    def get_five_events(self):
        date_today = timezone.now()
        return (
            self.get_queryset()
            .filter(event_start__gt=date_today)
            .order_by("event_start")[:5]
        )


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

    def get_queryset(self):
        return super().get_queryset().filter(post_type="E")

    def get_future_events(self):
        date_today = timezone.now()
        return (
            self.get_queryset()
            .filter(event_start__gt=date_today)
            .order_by("event_start")
        )

    def get_past_events(self):
        date_today = timezone.now()
        return (
            self.get_queryset()
            .filter(event_start__lt=date_today)
            .order_by("-event_start")
        )


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

    def get_queryset(self):
        return super().get_queryset().filter(post_type="F")

    def _get_future_events(self):
        date_today = timezone.now()
        return (
            self.get_queryset()
            .filter(event_start__gt=date_today)
            .order_by("event_start")
        )

    def _get_past_events(self):
        date_today = timezone.now()
        return (
            self.get_queryset()
            .filter(event_start__lt=date_today)
            .order_by("-event_start")
        )

    def get_meetings(self):
        meetings = []

        if self._get_future_events().first():
            meetings.append(self._get_future_events().first())

        if self._get_past_events().first():
            meetings.append(self._get_past_events().first())

        return meetings