Source code for intranet.apps.enrichment.models

import datetime

from django.conf import settings
from django.contrib.auth.models import Group as DjangoGroup
from django.db import models
from django.db.models import Manager
from django.utils import timezone

from ...utils.date import get_date_range_this_year, is_current_year
from ...utils.deletion import set_historical_user


class EnrichmentActivityQuerySet(models.query.QuerySet):
    def this_year(self):
        """Get enrichment activities created during this school year.

        Returns:
            Enrichment activities created during this school year.
        """
        start_date, end_date = get_date_range_this_year()
        return self.filter(added__gte=start_date, added__lte=end_date)


class EnrichmentActivityManager(Manager):
    def get_queryset(self):
        return EnrichmentActivityQuerySet(self.model, using=self._db)

    def visible_to_user(self, *args):  # , user):
        """Get a list of visible enrichment activities for a given user (usually request.user).

        TODO: implement this method. Add group restrictions.
        """

        return EnrichmentActivity.objects.all().this_year()


class EnrichmentActivity(models.Model):
    """An enrichment activity available to the TJ community."""

    objects = EnrichmentActivityManager()

    title = models.CharField(max_length=100)
    description = models.TextField(max_length=10000)
    added = models.DateTimeField(auto_now=True)

    time = models.DateTimeField(blank=True, null=True)
    location = models.CharField(max_length=300)
    user = models.ForeignKey(settings.AUTH_USER_MODEL, null=True, on_delete=set_historical_user)

    capacity = models.SmallIntegerField(default=28)
    attending = models.ManyToManyField(settings.AUTH_USER_MODEL, blank=True, related_name="enrichments_attending")

    attended = models.ManyToManyField(settings.AUTH_USER_MODEL, blank=True, related_name="enrichments_attended")
    attendance_taken = models.BooleanField(default=False)

    presign = models.BooleanField(default=False)

    groups_allowed = models.ManyToManyField(DjangoGroup, related_name="allowed_enrichments_set", blank=True)
    groups_blacklisted = models.ManyToManyField(DjangoGroup, related_name="blacklisted_enrichments_set", blank=True)

    def user_can_signup(self, user):
        """Return whether a user can sign up for an enrichment activity.

        Args:
            user: The user to check.

        Returns:
            Whether the user can sign up for the enrichment activity.
        """
        return (not self.groups_allowed.exists() or any(group in user.groups.all() for group in self.groups_allowed.all())) and not any(
            group in user.groups.all() for group in self.groups_blacklisted.all()
        )

    def user_is_blacklisted(self, user):
        return any(group in user.groups.all() for group in self.groups_blacklisted.all())

    @property
    def is_this_year(self):
        """Return whether the enrichment activity was created after the start of the school year."""
        return is_current_year(self.added)

    @property
    def happened(self):
        """Return whether an enrichment activity has happened."""
        return self.time < timezone.now()

    @property
    def restricted(self):
        return self.groups_allowed.exists()

    @property
    def is_too_early_to_signup(self):
        """Returns whether it is too early to sign up for the activity
        if it is a presign.
        This contains the 2 day presign logic.

        Returns:
            Whether it is too early to sign up for this scheduled activity
            and when the activity opens for signups.
        """
        now = timezone.localtime()

        # Midnight of the day of the activity
        activity_date = self.time.astimezone(timezone.get_default_timezone())
        activity_date = datetime.datetime.combine(activity_date.date(), datetime.time(0, 0, 0), tzinfo=activity_date.tzinfo)

        presign_period = datetime.timedelta(minutes=settings.EIGHTH_PRESIGNUP_HOURS * 60 + settings.EIGHTH_PRESIGNUP_MINUTES)

        return (now < (activity_date - presign_period), activity_date - presign_period)

    def __str__(self):
        return f"{self.title} - {self.time}"

    class Meta:
        ordering = ["time"]
        verbose_name_plural = "enrichment activities"