fix(#1701): Events page displays year for events scheduled to start or end at a future year

events/models.py

@@ -181,6 +181,20 @@ def next_time(self):
         except IndexError:
             return None
 
+    def is_scheduled_to_start_this_year(self) -> bool:
+        if self.next_time:
+            current_year: int = timezone.now().year
+            if self.next_time.dt_start.year == current_year:
+                return True
+        return False
+
+    def is_scheduled_to_end_this_year(self) -> bool:
+        if self.next_time:
+            current_year: int = timezone.now().year
+            if self.next_time.dt_end.year == current_year:
+                return True
+        return False
+
     @property
     def previous_time(self):
         now = timezone.now()

events/tests/test_models.py

@@ -1,4 +1,6 @@
 import datetime
+from types import SimpleNamespace
+from unittest.mock import patch
 
 from django.contrib.auth import get_user_model
 from django.test import TestCase
@@ -62,7 +64,6 @@ def test_recurring_event(self):
         self.assertEqual(self.event.next_time.dt_start, recurring_time_dtstart)
         self.assertTrue(rt.valid_dt_end())
 
-
         rt.begin = now - datetime.timedelta(days=5)
         rt.finish = now - datetime.timedelta(days=3)
         rt.save()
@@ -186,3 +187,61 @@ def test_event_previous_event(self):
         # 'Event.previous_event' can return None if there is no
         # OccurringRule or RecurringRule found.
         self.assertIsNone(self.event.previous_event)
+
+    def test_scheduled_to_start_this_year_method(self):
+        test_datetime = SimpleNamespace(
+            now=lambda: timezone.datetime(timezone.now().year,
+                                          6, 1, tzinfo=timezone.now().tzinfo)
+        )
+
+        with patch("django.utils.timezone", new=test_datetime) as mock_timezone:
+            with patch("events.models.timezone", new=test_datetime):
+                now = seconds_resolution(mock_timezone.now())
+
+                occurring_time_dtstart = now + datetime.timedelta(days=1)
+                OccurringRule.objects.create(
+                    event=self.event,
+                    dt_start=occurring_time_dtstart,
+                    dt_end=occurring_time_dtstart + datetime.timedelta(days=3)
+                )
+                self.assertTrue(self.event.is_scheduled_to_start_this_year())
+
+                OccurringRule.objects.get(event=self.event).delete()
+
+                event_not_scheduled_to_start_this_year_occurring_time_dtstart = now + datetime.timedelta(days=365)
+                OccurringRule.objects.create(
+                    event=self.event,
+                    dt_start=event_not_scheduled_to_start_this_year_occurring_time_dtstart,
+                    dt_end=event_not_scheduled_to_start_this_year_occurring_time_dtstart + datetime.timedelta(days=3)
+                )
+
+                self.assertFalse(self.event.is_scheduled_to_start_this_year())
+
+    def test_scheduled_to_end_this_year_method(self):
+        test_datetime = SimpleNamespace(
+            now=lambda: timezone.datetime(timezone.now().year,
+                                          6, 1, tzinfo=timezone.now().tzinfo)
+        )
+
+        with patch("django.utils.timezone", new=test_datetime) as mock_timezone:
+            with patch("events.models.timezone", new=test_datetime):
+                now = seconds_resolution(mock_timezone.now())
+                occurring_time_dtstart = now + datetime.timedelta(days=1)
+
+                OccurringRule.objects.create(
+                    event=self.event,
+                    dt_start=occurring_time_dtstart,
+                    dt_end=occurring_time_dtstart
+                )
+
+                self.assertTrue(self.event.is_scheduled_to_end_this_year())
+
+                OccurringRule.objects.get(event=self.event).delete()
+
+                OccurringRule.objects.create(
+                    event=self.event,
+                    dt_start=now,
+                    dt_end=now + datetime.timedelta(days=365)
+                )
+
+                self.assertFalse(self.event.is_scheduled_to_end_this_year())

events/tests/test_views.py

@@ -6,7 +6,7 @@
 from django.test import TestCase
 from django.utils import timezone
 
-from ..models import Calendar, Event, EventCategory, EventLocation, RecurringRule
+from ..models import Calendar, Event, EventCategory, EventLocation, RecurringRule, OccurringRule
 from ..templatetags.events import get_events_upcoming
 from users.factories import UserFactory
 
@@ -18,6 +18,11 @@ def setUpTestData(cls):
         cls.calendar = Calendar.objects.create(creator=cls.user, slug="test-calendar")
         cls.event = Event.objects.create(creator=cls.user, calendar=cls.calendar)
         cls.event_past = Event.objects.create(title='Past Event', creator=cls.user, calendar=cls.calendar)
+        cls.event_single_day = Event.objects.create(title="Single Day Event", creator=cls.user, calendar=cls.calendar)
+        cls.event_starts_at_future_year = Event.objects.create(title='Event Starting Following Year',
+                                                               creator=cls.user, calendar=cls.calendar)
+        cls.event_ends_at_future_year = Event.objects.create(title='Event Ending Following Year',
+                                                             creator=cls.user, calendar=cls.calendar)
 
         cls.now = timezone.now()
 
@@ -34,7 +39,6 @@ def setUpTestData(cls):
             begin=cls.now - datetime.timedelta(days=2),
             finish=cls.now - datetime.timedelta(days=1),
         )
-
         # Future event
         cls.future_event = Event.objects.create(title='Future Event', creator=cls.user, calendar=cls.calendar, featured=True)
         RecurringRule.objects.create(
@@ -67,18 +71,36 @@ def setUpTestData(cls):
             finish=cls.now - datetime.timedelta(days=1),
         )
 
+        cls.rule_single_day = OccurringRule.objects.create(
+            event=cls.event_single_day,
+            dt_start=recurring_time_dtstart,
+            dt_end=recurring_time_dtstart
+        )
+        cls.rule_future_start_year = OccurringRule.objects.create(
+            event=cls.event_starts_at_future_year,
+            dt_start=recurring_time_dtstart + datetime.timedelta(weeks=52),
+            dt_end=recurring_time_dtstart + datetime.timedelta(weeks=53),
+        )
+        cls.rule_future_end_year = OccurringRule.objects.create(
+            event=cls.event_ends_at_future_year,
+            dt_start=recurring_time_dtstart,
+            dt_end=recurring_time_dtend + datetime.timedelta(weeks=52)
+        )
+
     def test_events_homepage(self):
         url = reverse('events:events')
         response = self.client.get(url)
         events = response.context['object_list']
         event_titles = [event.title for event in events]
 
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(len(events), 6)
+        self.assertEqual(len(events), 9)
 
         self.assertIn('Future Event', event_titles)
         self.assertIn('Current Event', event_titles)
         self.assertIn('Past Event', event_titles)
+        self.assertIn('Event Starting Following Year', event_titles)
+        self.assertIn('Event Ending Following Year', event_titles)
 
     def test_calendar_list(self):
         calendars_count = Calendar.objects.count()
@@ -93,7 +115,7 @@ def test_event_list(self):
         response = self.client.get(url)
 
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(len(response.context['object_list']), 3)
+        self.assertEqual(len(response.context['object_list']), 6)
 
         url = reverse('events:event_list_past', kwargs={"calendar_slug": 'unexisting'})
         response = self.client.get(url)
@@ -189,12 +211,21 @@ def test_event_detail(self):
         self.assertEqual(self.event, response.context['object'])
 
     def test_upcoming_tag(self):
-        self.assertEqual(len(get_events_upcoming()), 3)
+        self.assertEqual(len(get_events_upcoming()), 5)
         self.assertEqual(len(get_events_upcoming(only_featured=True)), 1)
         self.rule.begin = self.now - datetime.timedelta(days=3)
         self.rule.finish = self.now - datetime.timedelta(days=2)
         self.rule.save()
-        self.assertEqual(len(get_events_upcoming()), 2)
+        self.assertEqual(len(get_events_upcoming()), 5)
+
+    def test_event_starting_future_year_displays_relevant_year(self):
+        event = self.event_starts_at_future_year
+        url = reverse('events:events')
+        response = self.client.get(url)
+        self.assertIn(
+            f'<span id="start-{event.id}">',
+            response.content.decode()
+        )
 
     def test_context_data(self):
         url = reverse("events:events")
@@ -204,6 +235,23 @@ def test_context_data(self):
         self.assertIn("upcoming_events", response.context)
         self.assertIn("events_now", response.context)
 
+    def test_event_ending_future_year_displays_relevant_year(self):
+        event = self.event_ends_at_future_year
+        url = reverse('events:events')
+        response = self.client.get(url)
+        self.assertIn(
+            f'<span id="end-{event.id}">',
+            response.content.decode()
+        )
+
+    def test_events_scheduled_current_year_does_not_display_current_year(self):
+        event = self.event_single_day
+        url = reverse('events:events')
+        response = self.client.get(url)
+        self.assertIn(  # start date
+            f'<span id="start-{event.id}" class="say-no-more">',
+            response.content.decode()
+        )
 
 class EventSubmitTests(TestCase):
     event_submit_url = reverse_lazy('events:event_submit')

templates/events/event_list.html

@@ -73,7 +73,11 @@ <h3 class="event-title"><a href="{{ object.get_absolute_url }}">{{ object.title|
                         </h3>
                         <p>
                             {% with object.next_time as next_time %}
-                                {% include "events/includes/time_tag.html" %}
+                                {% with object.is_scheduled_to_start_this_year as scheduled_start_this_year %}
+                                    {% with object.is_scheduled_to_end_this_year as scheduled_end_this_year %}
+                                        {% include "events/includes/time_tag.html" %}
+                                    {% endwith %}
+                                {% endwith %}
                             {% endwith %}
 
                             {% if object.venue %}
@@ -98,7 +102,11 @@ <h3 class="event-title"><a
                                     href="{{ object.get_absolute_url }}">{{ object.title|striptags }}</a></h3>
                             <p>
                                 {% with object.previous_time as next_time %}
-                                    {% include "events/includes/time_tag.html" %}
+                                    {% with object.is_scheduled_to_start_this_year as scheduled_start_this_year %}
+                                        {% with object.is_scheduled_to_end_this_year as scheduled_end_this_year %}
+                                            {% include "events/includes/time_tag.html" %}
+                                        {% endwith %}
+                                    {% endwith %}
                                 {% endwith %}
 
                                 {% if object.venue %}

templates/events/includes/time_tag.html

@@ -1,5 +1,32 @@
 {% if next_time.single_day %}
-<time datetime="{{ next_time.dt_start|date:'c' }}">{{ next_time.dt_start|date:"d N" }}<span class="say-no-more"> {{ next_time.dt_start|date:"Y" }}</span>{% if not next_time.all_day %} {{ next_time.dt_start|date:"fA"|lower }} {{ next_time.dt_start|date:"e" }}{% if next_time.valid_dt_end %} – {{ next_time.dt_end|date:"fA"|lower }} {{ next_time.dt_end|date:"e" }}{% endif %}{% endif %}</time>
+    <time datetime="{{ next_time.dt_start|date:'c' }}">{{ next_time.dt_start|date:"d N" }}
+        <span id="start-{{ object.id }}"{% if scheduled_start_this_year %} class="say-no-more"{% endif %}>
+            {{ next_time.dt_start|date:"Y" }}
+        </span>
+
+        <span id="start-{{ object.id }}"{% if scheduled_end_this_year %} class="say-no-more"{% endif %}>
+            {{ next_time.dt_start|date:"Y" }}
+        </span>
+
+        {% if not next_time.all_day %}
+            {{ next_time.dt_start|date:"fA"|lower }} {{ next_time.dt_start|date:"e" }}
+                {% if next_time.valid_dt_end %} – {{ next_time.dt_end|date:"fA"|lower }}
+                    {{ next_time.dt_end|date:"e" }}
+                {% endif %}
+        {% endif %}
+    </time>
 {% else %}
-<time datetime="{{ next_time.dt_start|date:'c' }}">{{ next_time.dt_start|date:"d N" }}{% if next_time.valid_dt_end %} &ndash; {{ next_time.dt_end|date:"d N" }}{% endif %} <span class="say-no-more"> {{ next_time.dt_end|date:"Y" }}</span></time>
+    <time datetime="{{ next_time.dt_start|date:'c' }}">{{ next_time.dt_start|date:"d N" }}
+        <span id="start-{{ object.id }}"{% if scheduled_start_this_year %} class="say-no-more"{% endif %}>
+            {{ next_time.dt_start|date:"Y" }}
+        </span>
+
+        {% if next_time.valid_dt_end %} &ndash;
+            {{ next_time.dt_end|date:"d N" }}
+        {% endif %}
+
+        <span id="end-{{ object.id }}"{% if scheduled_end_this_year %} class="say-no-more"{% endif %}>
+            {{ next_time.dt_end|date:"Y" }}
+        </span>
+    </time>
 {% endif %}