Sep 26, 2024 · Dec 25, 2020 · Dec 25, 2020 · Dec 25, 2020 · Dec 25, 2020 · Dec 25, 2020
diff --git a/events/models.py b/events/models.py
        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()
diff --git a/events/tests/test_models.py b/events/tests/test_models.py
 import datetime
 from types import SimpleNamespace
 from unittest.mock import patch

 from django.contrib.auth import get_user_model
 from django.test import TestCase
        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()
        # '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())
diff --git a/events/tests/test_views.py b/events/tests/test_views.py
 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

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

            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(
            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()
        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)
        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")
        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')
diff --git a/templates/events/event_list.html b/templates/events/event_list.html
                        </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 %}
                                    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 %}
diff --git a/templates/events/includes/time_tag.html b/templates/events/includes/time_tag.html
 {% 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 %}
Original file line number	Diff line number	Diff line change
Expand Up		@@ -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()
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -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
Expand DownExpand Up		@@ -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()
Expand DownExpand Up		@@ -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())
Original file line number	Diff line number	Diff line change
Expand Up		@@ -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

Expand All		@@ -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()

Expand All		@@ -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(
Expand DownExpand Up		@@ -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()
Expand All		@@ -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)
Expand DownExpand Up		@@ -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")
Expand All		@@ -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')
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -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 %}
Expand All		@@ -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 %}
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -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 %} – {{ 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 %} –
		{{ 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 %}