from datetime import date, datetime, timedelta from django import forms from django.contrib.auth.models import Group, User from django.db import models from django.forms import CheckboxSelectMultiple from django.utils import timezone from modelcluster.contrib.taggit import ClusterTaggableManager from modelcluster.fields import ParentalKey from taggit.models import TaggedItemBase from wagtail.admin.panels import FieldPanel from wagtail.fields import RichTextField, StreamField from wagtail.models import Page from wagtail.models.copying import ParentalManyToManyField from wagtail_color_panel.edit_handlers import NativeColorPanel from wagtail_color_panel.fields import ColorField class EmptyPage(Page): pass class HomePage(Page): body = RichTextField(blank=True) content_panels = Page.content_panels + ["body"] class CoursePage(Page): body = RichTextField(blank=True) course_image = models.ForeignKey( "wagtailimages.Image", null=True, blank=True, on_delete=models.SET_NULL, related_name="+", ) allowed_groups = ParentalManyToManyField( Group, related_name="course_pages", help_text="Select a group to restrict access to this course. Non-members will be prompted to purchase the course to view modules.", ) def _user_has_access(self, user): if not user.is_authenticated: return False user_group_ids = user.groups.values_list("id", flat=True) return self.allowed_groups.filter(id__in=user_group_ids).exists() # pyright: ignore[reportAttributeAccessIssue] def get_context(self, request): context = super().get_context(request) context["user_has_access"] = self._user_has_access(request.user) return context content_panels = Page.content_panels + [ FieldPanel("course_image"), FieldPanel("body"), FieldPanel("allowed_groups", widget=CheckboxSelectMultiple), ] class CourseModulePage(Page): body = RichTextField(blank=True) @property def course(self): if hasattr(self, "get_parent"): parent = self.get_parent() if parent and hasattr(parent, "specific"): return parent.specific return None @property def full_title(self): course = self.course if course: return f"{course.title} - {self.title}" return self.title content_panels = Page.content_panels + ["body"] class EventPageTag(TaggedItemBase): content_object = ParentalKey( "home.EventPage", related_name="tagged_items", on_delete=models.CASCADE, ) class EventPage(Page): tags = ClusterTaggableManager(through=EventPageTag, blank=True) color = ColorField(default="#1c398e") image = models.ForeignKey( "wagtailimages.Image", null=True, blank=True, on_delete=models.SET_NULL, related_name="+", ) start = models.DateTimeField( blank=True, null=True, help_text="Start date and time of the singular event (ignored if recurrence is enabled)", ) end = models.DateTimeField( blank=True, null=True, help_text="End date and time of the singular event (ignored if recurrence is enabled)", ) # Recurrence fields recurrence_enabled = models.BooleanField( default=False, help_text="Enable automatic recurrence for this event" ) RECURRENCE_DAYS = [ (0, "Monday"), (1, "Tuesday"), (2, "Wednesday"), (3, "Thursday"), (4, "Friday"), (5, "Saturday"), (6, "Sunday"), ] recurrence_days_of_week = models.JSONField( default=list, blank=True, help_text="Days of the week for recurrence (e.g., [0,3] for Mon & Thu)", ) recurrence_start_time = models.TimeField( null=True, blank=True, help_text="Start time for each occurrence" ) recurrence_end_time = models.TimeField( null=True, blank=True, help_text="End time for each occurrence" ) recurrence_repeat_until = models.DateField( null=True, blank=True, help_text="Repeat until this date (inclusive)" ) recurrence_endless = models.BooleanField( default=False, help_text="If enabled, recurrence will not end (ignore 'repeat until' date)", ) # TODO: use google maps here location = models.CharField(max_length=255, blank=True) max_attendees = models.PositiveIntegerField( null=True, blank=True, help_text="Maximum number of attendees. Leave blank for unlimited.", ) description = RichTextField(blank=True) hosts = ParentalManyToManyField( User, related_name="hosted_events", help_text="Select users who will be listed as hosts of this event.", ) def get_context(self, request): context = super().get_context(request) # Occurrence-specific context should be handled in views/templates return context def generate_occurrences(self, days_ahead=30): """ Generate EventOccurrence objects for this event based on recurrence settings. For endless recurrence, generate up to days_ahead into the future. """ now = timezone.now() if not self.recurrence_enabled: # if recurrence is not enabled, ensure there's at least one occurrence for the specified start/end if self.occurrences.exists(): occurrence = self.occurrences.first() if occurrence.start != self.start or occurrence.end != self.end: occurrence.start = self.start occurrence.end = self.end occurrence.save(update_fields=["start", "end"]) else: EventOccurrence.objects.create( event=self, start=self.start, end=self.end ) return # Determine the date range start_date = now.date() if self.recurrence_endless: end_date = start_date + timedelta(days=days_ahead) elif self.recurrence_repeat_until: end_date = self.recurrence_repeat_until else: end_date = start_date + timedelta(days=days_ahead) days_of_week = self.recurrence_days_of_week or [] start_time = self.recurrence_start_time or datetime.min.time() end_time = self.recurrence_end_time or datetime.min.time() for single_date in ( start_date + timedelta(n) for n in range((end_date - start_date).days + 1) ): if days_of_week and single_date.weekday() not in days_of_week: continue start_dt = datetime.combine(single_date, start_time) end_dt = datetime.combine(single_date, end_time) start_dt = timezone.make_aware(start_dt) end_dt = timezone.make_aware(end_dt) # If an occurrence exists, update its start/end if needed, but keep signed_up_users occurrence = self.occurrences.filter(start=start_dt, end=end_dt).first() if occurrence: if occurrence.start != start_dt or occurrence.end != end_dt: occurrence.start = start_dt occurrence.end = end_dt occurrence.save(update_fields=["start", "end"]) else: EventOccurrence.objects.create(event=self, start=start_dt, end=end_dt) def save(self, *args, **kwargs): super().save(*args, **kwargs) self.generate_occurrences() content_panels = Page.content_panels + [ FieldPanel("tags"), NativeColorPanel("color"), FieldPanel("image"), FieldPanel("location"), FieldPanel("max_attendees"), FieldPanel("hosts", widget=CheckboxSelectMultiple), FieldPanel("description"), FieldPanel("start"), FieldPanel("end"), FieldPanel("recurrence_enabled"), FieldPanel("recurrence_days_of_week"), FieldPanel("recurrence_start_time"), FieldPanel("recurrence_end_time"), FieldPanel("recurrence_repeat_until"), FieldPanel("recurrence_endless"), ] class EventOccurrence(models.Model): event = ParentalKey(EventPage, related_name="occurrences", on_delete=models.CASCADE) start = models.DateTimeField() end = models.DateTimeField() signed_up_users = models.ManyToManyField( User, related_name="event_occurrences_signed_up", blank=True, help_text="Users who have signed up for this occurrence.", ) class Meta: ordering = ["start"] def __str__(self): return f"{self.event.title} ({self.start} - {self.end})" @property def attendees_count(self): return self.signed_up_users.count() @property def is_past(self): from django.utils import timezone return self.end < timezone.now() def user_signed_up(self, user): if not user.is_authenticated: return False return self.signed_up_users.filter(id=user.id).exists()