def setUp(self):
weekly = Rule(frequency="WEEKLY")
weekly.save()
daily = Rule(frequency="DAILY")
daily.save()
cal = Calendar(name="MyCal")
cal.save()
self.event1 = Event(**{
'title': 'Weekly Event',
'start': datetime.datetime(2009, 4, 1, 8, 0),
'end': datetime.datetime(2009, 4, 1, 9, 0),
'end_recurring_period': datetime.datetime(2009, 10, 5, 0, 0),
'rule': weekly,
'calendar': cal
})
self.event1.save()
self.event2 = Event(**{
'title': 'Recent Event',
'start': datetime.datetime(2008, 1, 5, 9, 0),
'end': datetime.datetime(2008, 1, 5, 10, 0),
'end_recurring_period': datetime.datetime(2009, 5, 5, 0, 0),
'rule': daily,
'calendar': cal
})
self.event2.save()
def setUp(self):
rule = Rule(frequency="WEEKLY")
rule.save()
cal = Calendar(name="MyCal")
cal.save()
self.recurring_data = {
'title': 'Recent Event',
'start': datetime.datetime(2008, 1, 5, 8, 0, tzinfo=pytz.utc),
'end': datetime.datetime(2008, 1, 5, 9, 0, tzinfo=pytz.utc),
'end_recurring_period': datetime.datetime(2008, 5, 5, 0, 0, tzinfo=pytz.utc),
'rule': rule,
'calendar': cal
}
self.data = {
'title': 'Recent Event',
'start': datetime.datetime(2008, 1, 5, 8, 0, tzinfo=pytz.utc),
'end': datetime.datetime(2008, 1, 5, 9, 0, tzinfo=pytz.utc),
'end_recurring_period': datetime.datetime(2008, 5, 5, 0, 0, tzinfo=pytz.utc),
'calendar': cal
}
self.near_periodend_recurring_data = {
'title': 'Special Event',
'start': datetime.datetime(2014, 5, 1, 8, 0, tzinfo=pytz.utc),
'end': datetime.datetime(2014, 5, 1, 9, 0, tzinfo=pytz.utc),
'end_recurring_period': datetime.datetime(2014, 5, 8, 9, 0, tzinfo=pytz.utc),
'rule': rule,
'calendar': cal
}
self.recurring_event = Event.objects.create(**self.recurring_data)
self.start = datetime.datetime(2008, 1, 12, 0, 0, tzinfo=pytz.utc)
self.end = datetime.datetime(2008, 1, 27, 0, 0, tzinfo=pytz.utc)
def test_edge_case_events(self):
cal = Calendar(name="MyCal")
cal.save()
data_1 = {
'title': 'Edge case event test one',
'start': datetime.datetime(2013, 1, 5, 8, 0, tzinfo=pytz.utc),
'end': datetime.datetime(2013, 1, 5, 9, 0, tzinfo=pytz.utc),
'calendar': cal
}
data_2 = {
'title': 'Edge case event test two',
'start': datetime.datetime(2013, 1, 5, 9, 0, tzinfo=pytz.utc),
'end': datetime.datetime(2013, 1, 5, 12, 0, tzinfo=pytz.utc),
'calendar': cal
}
event_one = Event(**data_1)
event_two = Event(**data_2)
event_one.save()
event_two.save()
occurrences_two = event_two.get_occurrences(datetime.datetime(2013, 1, 5, 9, 0, tzinfo=pytz.utc),
datetime.datetime(2013, 1, 5, 12, 0, tzinfo=pytz.utc))
self.assertEqual(1, len(occurrences_two))
occurrences_one = event_one.get_occurrences(datetime.datetime(2013, 1, 5, 9, 0, tzinfo=pytz.utc),
datetime.datetime(2013, 1, 5, 12, 0, tzinfo=pytz.utc))
self.assertEqual(0, len(occurrences_one))
def create(request, form_class=TribeForm, template_name="tribes/create.html"):
if request.user.is_authenticated() and request.method == "POST":
if request.POST["action"] == "create":
tribe_form = form_class(request.POST)
if tribe_form.is_valid():
tribe = tribe_form.save(commit=False)
tribe.creator = request.user
tribe.save()
tribe.members.add(request.user)
tribe.save()
# @@@ this is just temporary to give tribes a single calendar -- will revisit during whole
# tribe/project merge effort
calendar = Calendar(name = "%s Calendar" % tribe.name)
calendar.save()
CalendarRelation.objects.create_relation(calendar, tribe, distinction="default", inheritable=True)
if notification:
# @@@ might be worth having a shortcut for sending to all users
notification.send(User.objects.all(), "tribes_new_tribe", {"tribe": tribe}, queue=True)
if friends: # @@@ might be worth having a shortcut for sending to all friends
notification.send((x['friend'] for x in Friendship.objects.friends_for_user(tribe.creator)), "tribes_friend_tribe", {"tribe": tribe})
#return render_to_response("base.html", {
#}, context_instance=RequestContext(request))
return HttpResponseRedirect(tribe.get_absolute_url())
else:
tribe_form = form_class()
else:
tribe_form = form_class()
return render_to_response(template_name, {
"tribe_form": tribe_form,
}, context_instance=RequestContext(request))
def test_recurring_event_with_moved_get_occurrences_after(self):
cal = Calendar(name="MyCal")
cal.save()
rule = Rule(frequency="WEEKLY")
rule.save()
recurring_event= self.__create_recurring_event(
'Recurrent event test get_occurrence',
datetime.datetime(2008, 1, 5, 8, 0, tzinfo=pytz.utc),
datetime.datetime(2008, 1, 5, 9, 0, tzinfo=pytz.utc),
datetime.datetime(2008, 5, 5, 0, 0, tzinfo=pytz.utc),
rule,
cal,
)
recurring_event.save()
occurrence = recurring_event.get_occurrence(datetime.datetime(2008, 1, 12, 8, 0, tzinfo=pytz.utc))
occurrence.move(
datetime.datetime(2008, 1, 15, 8, 0, tzinfo=pytz.utc),
datetime.datetime(2008, 1, 15, 9, 0, tzinfo=pytz.utc))
gen = recurring_event.occurrences_after(
datetime.datetime(2008, 1, 14, 8, 0, tzinfo=pytz.utc))
occurrence2 = next(gen)
# end = datetime.datetime(2008, 1, 6, tzinfo=pytz.utc))
#occurrence = occurrences[0]
#occurrence2 = recurring_event.occurrences_after(datetime.datetime(2008, 1, 5, tzinfo=pytz.utc)).next()
self.assertEqual(occurrence, occurrence2)
def test_recurring_event_get_occurrence_in_timezone(self):
cal = Calendar(name="MyCal")
cal.save()
rule = Rule(frequency = "WEEKLY")
rule.save()
# Event start and end are UTC because that is what is coming
# from the database
event = self.__create_recurring_event(
'Recurrent event test get_occurrence',
datetime.datetime(2014, 3, 21, 6, 0, tzinfo=pytz.utc),
datetime.datetime(2014, 3, 21, 8, 0, tzinfo=pytz.utc),
datetime.datetime(2014, 4, 11, 0, 0, tzinfo=pytz.utc),
rule,
cal,
)
event.save()
tzinfo = pytz.timezone('Europe/Helsinki')
start = tzinfo.localize(datetime.datetime(2014, 3, 28, 8, 0)) # +2
occurrence = event.get_occurrence(start)
self.assertEqual(occurrence.start, start)
occurrence.save()
# DST change on March 30th from +2 to +3
start = tzinfo.localize(datetime.datetime(2014, 4, 4, 8, 0)) # +3
occurrence = event.get_occurrence(start)
self.assertEqual(occurrence.start, start)
def save(self, force_insert=False, force_update=False):
super(CircleEvent, self).save(force_insert, force_update)
try:
cal = Calendar.objects.get(pk=1)
except Calendar.DoesNotExist:
cal = Calendar(name="Community Calendar")
cal.save()
cal.events.add(self)
def test_get_calendar_for_object(self):
calendar = Calendar(name='My Cal')
calendar.save()
rule = Rule()
rule.save()
calendar.create_relation(rule)
result = Calendar.objects.get_calendar_for_object(rule)
self.assertEqual(result.name, 'My Cal')
class TestEventViews(LoggedInTestCase):
def setUp(self):
super(TestEventViews, self).setUp()
self.cal = Calendar(
name=random_string(),
slug=random_string(),
)
self.cal.save()
self.event = Event(
start=timezone.now(),
end=timezone.now() + timedelta(weeks=6),
title=random_string(),
calendar=self.cal,
)
self.event.save()
def tearDown(self):
super(TestEventViews, self).tearDown()
try:
self.cal.delete()
self.event.delete()
except:
pass
def test_event_can_be_recurring(self):
rule = Rule(
name=random_string(),
description=random_string(),
frequency='WEEKLY',
)
rule.save()
try:
url = reverse(
'openduty.events.create_or_edit_event',
kwargs = {
'calendar_slug': self.cal.slug,
'event_id': str(self.event.id),
},
)
response = self.client.post(
path = url,
data = {
"start_0": self.event.start.strftime('%Y-%m-%d'),
"start_1": "09:00",
"end_0": self.event.end.strftime('%Y-%m-%d'),
"end_1": "23:00",
"description": "desc",
"rule": str(rule.id),
"oncall": "foo",
"fallback": "bar",
},
)
self.assertEqual(302, response.status_code)
e = Event.objects.get(id=self.event.id)
self.assertEqual(rule, e.rule)
finally:
rule.delete()
def test_occurrences_after_with_events_before_returns_empty(self):
calendar = Calendar()
calendar.save()
start_after = timezone.now() + datetime.timedelta(days=-1)
end_after = start_after + datetime.timedelta(hours=1)
event = self.__create_event(start_after, end_after)
calendar.events.add(event)
occurrences = list(calendar.occurrences_after(timezone.now()))
self.assertEqual(occurrences, [])
def test_get_calendar_for_object_with_more_than_one_calendar(self):
calendar_1 = Calendar(name='My Cal 1')
calendar_1.save()
calendar_2 = Calendar(name='My Cal 2')
calendar_2.save()
rule = Rule()
rule.save()
calendar_1.create_relation(rule)
calendar_2.create_relation(rule)
with self.assertRaises(AssertionError):
result = Calendar.objects.get_calendar_for_object(rule)
def test_occurrences_after_with_events_after_returns_events(self):
calendar = Calendar()
calendar.save()
start_after = timezone.now() + datetime.timedelta(days=1)
end_after = start_after + datetime.timedelta(hours=1)
event = self.__create_event(start_after, end_after)
calendar.events.add(event)
occurrences = list(calendar.occurrences_after(timezone.now()))
self.assertEquals(len(occurrences), 1)
self.assertEquals(occurrences[0].start, start_after)
self.assertEquals(occurrences[0].end, end_after)
def test_event_get_ocurrence(self):
cal = Calendar(name='MyCal')
cal.save()
start = timezone.now() + datetime.timedelta(days=1)
event = self.__create_event(
'Non recurring event test get_occurrence',
start,
start + datetime.timedelta(hours=1),
cal)
event.save()
occurrence = event.get_occurrence(start)
self.assertEqual(occurrence.start, start)
def optionnal_calendar_new(sender, **kwargs):
event = kwargs.pop('instance')
if not isinstance(event, Event):
return True
if not event.calendar:
try:
calendar = Calendar._default_manager.get(name='defaulter')
except Calendar.DoesNotExist:
calendar = Calendar(name='defaulter', slug='defaulter')
calendar.save()
event.calendar = calendar
return True
def setUp(self):
rule = Rule(frequency="WEEKLY")
rule.save()
cal = Calendar(name="MyCal")
cal.save()
data = {
'title': 'Recent Event',
'start': datetime.datetime(2008, 1, 5, 8, 0),
'end': datetime.datetime(2008, 1, 5, 9, 0),
'end_recurring_period': datetime.datetime(2008, 5, 5, 0, 0),
'rule': rule,
'calendar': cal
}
self.recurring_event = Event(**data)
self.recurring_event.save()
def test_occurences_with_recurrent_event_end_recurring_period_edge_case(
self):
cal = Calendar(name='MyCal')
cal.save()
rule = Rule(frequency="DAILY")
rule.save()
start = timezone.now() + datetime.timedelta(days=1)
event = self.__create_recurring_event(
'Non recurring event test get_occurrence', start,
start + datetime.timedelta(hours=1),
start + datetime.timedelta(days=10), rule, cal)
event.save()
occurrences = list(event.occurrences_after())
self.assertEqual(len(occurrences), 11)
def setUp(self):
rule = Rule(frequency = "WEEKLY")
rule.save()
cal = Calendar(name="MyCal")
cal.save()
data = {
'title': 'Recent Event',
'start': datetime.datetime(2008, 1, 5, 8, 0, tzinfo=pytz.utc),
'end': datetime.datetime(2008, 1, 5, 9, 0, tzinfo=pytz.utc),
'end_recurring_period' : datetime.datetime(2008, 5, 5, 0, 0, tzinfo=pytz.utc),
'rule': rule,
'calendar': cal
}
self.recurring_event = Event(**data)
self.recurring_event.save()
def test_occurences_after_with_no_params(self):
cal = Calendar(name='MyCal')
cal.save()
start = timezone.now() + datetime.timedelta(days=1)
event = self.__create_event(
'Non recurring event test get_occurrence',
start,
start + datetime.timedelta(hours=1),
cal)
event.save()
occurrences = list(event.occurrences_after())
self.assertEqual(len(occurrences), 1)
self.assertEqual(occurrences[0].start, start)
self.assertEqual(occurrences[0].end, start + datetime.timedelta(hours=1))
def setUp(self):
rule = Rule(frequency="WEEKLY")
rule.save()
cal = Calendar(name="MyCal")
cal.save()
data = {
"title": "Recent Event",
"start": datetime.datetime(2008, 1, 5, 8, 0, tzinfo=pytz.utc),
"end": datetime.datetime(2008, 1, 5, 9, 0, tzinfo=pytz.utc),
"end_recurring_period": datetime.datetime(2008, 5, 5, 0, 0, tzinfo=pytz.utc),
"rule": rule,
"calendar": cal,
}
self.recurring_event = Event(**data)
self.recurring_event.save()
class TestTemplateTags(TestCase):
def setUp(self):
self.day = Day(events=Event.objects.all(),
date=datetime.datetime(2008, 2, 7, 0, 0, tzinfo=pytz.utc))
rule = Rule(frequency="WEEKLY")
rule.save()
self.cal = Calendar(name="MyCal", slug="MyCalSlug")
self.cal.save()
data = {
'title': 'Recent Event',
'start': datetime.datetime(2008, 1, 5, 8, 0, tzinfo=pytz.utc),
'end': datetime.datetime(2008, 1, 5, 9, 0, tzinfo=pytz.utc),
'end_recurring_period': datetime.datetime(2008, 5, 5, 0, 0, tzinfo=pytz.utc),
'rule': rule,
'calendar': self.cal,
}
recurring_event = Event(**data)
recurring_event.save()
self.period = Period(events=Event.objects.all(),
start=datetime.datetime(2008, 1, 4, 7, 0, tzinfo=pytz.utc),
end=datetime.datetime(2008, 1, 21, 7, 0, tzinfo=pytz.utc))
def test_querystring_for_datetime(self):
date = datetime.datetime(2008, 1, 1, 0, 0, 0)
query_string = querystring_for_date(date, autoescape=True)
self.assertEqual(escape("?year=2008&month=1&day=1&hour=0&minute=0&second=0"),
query_string)
def test_prev_url(self):
query_string = prev_url("month_calendar", 'MyCalSlug', self.day)
expected = ("/calendar/month/MyCalSlug/?year=2008&month=2&day=6&hour=0"
"&minute=0&second=0")
self.assertEqual(query_string, escape(expected))
def test_next_url(self):
query_string = next_url("month_calendar", 'MyCalSlug', self.day)
expected = ("/calendar/month/MyCalSlug/?year=2008&month=2&day=8&hour=0"
"&minute=0&second=0")
self.assertEqual(query_string, escape(expected))
def test_create_event_url(self):
context = {}
slot = self.period.get_time_slot(datetime.datetime(2010, 1, 4, 7, 0, tzinfo=pytz.utc),
datetime.datetime(2008, 1, 4, 7, 12, tzinfo=pytz.utc))
query_string = create_event_url(context, self.cal, slot.start)
expected = ("/event/create/MyCalSlug/?year=2010&month=1&day=4&hour=7"
"&minute=0&second=0")
self.assertEqual(query_string['create_event_url'], escape(expected))
def test_prevent_type_error_when_comparing_dates_when_tz_off(self):
cal = Calendar(name="MyCal")
cal.save()
rule = Rule(frequency="WEEKLY")
rule.save()
event = self.__create_recurring_event(
'Recurrent event test get_occurrence',
datetime.datetime(2008, 1, 5, 8, 0),
datetime.datetime(2008, 1, 5, 9, 0),
datetime.datetime(2008, 5, 5, 0, 0),
rule,
cal,
)
naive_date = datetime.datetime(2008, 1, 20, 0, 0)
self.assertIsNone(event.get_occurrence(naive_date))
def test_get_absolute(self):
cal = Calendar(name='MyCal')
cal.save()
rule = Rule(frequency="DAILY")
rule.save()
start = timezone.now() + datetime.timedelta(days=1)
event = self.__create_recurring_event(
'Non recurring event test get_occurrence',
start,
start + datetime.timedelta(hours=1),
start + datetime.timedelta(days=10),
rule,
cal)
event.save()
url = event.get_absolute_url()
self.assertEqual(reverse('event', kwargs={'event_id': event.id}), url)
def test_get_occurrences_non_intersection_returns_empty_occ(self):
rule = Rule(frequency="DAILY")
rule.save()
cal = Calendar(name="MyCal")
cal.save()
recurring_data = {
'title': 'Recent Event',
'start': datetime.datetime(2016, 1, 5, 8, 0, tzinfo=pytz.utc),
'end': datetime.datetime(2016, 1, 5, 9, 0, tzinfo=pytz.utc),
'end_recurring_period': datetime.datetime(2016, 8, 5, 0, 0, tzinfo=pytz.utc),
'rule': rule,
'calendar': cal
}
recurring_event = Event.objects.create(**recurring_data)
occurrences = recurring_event.get_occurrences(start=self.start, end=self.end)
self.assertEqual(occurrences, [])
def test_prevent_type_error_when_comparing_dates_when_tz_off(self):
cal = Calendar(name="MyCal")
cal.save()
rule = Rule(frequency = "WEEKLY")
rule.save()
event = self.__create_recurring_event(
'Recurrent event test get_occurrence',
datetime.datetime(2008, 1, 5, 8, 0),
datetime.datetime(2008, 1, 5, 9, 0),
datetime.datetime(2008, 5, 5, 0, 0),
rule,
cal,
)
naive_date = datetime.datetime(2008, 1, 20, 0, 0)
self.assertIsNone(event.get_occurrence(naive_date))
def setUp(self):
rule = Rule(frequency="WEEKLY")
rule.save()
cal = Calendar(name="MyCal")
cal.save()
data = {
"title": "Recent Event",
"start": datetime.datetime(2008, 1, 5, 8, 0),
"end": datetime.datetime(2008, 1, 5, 9, 0),
"end_recurring_period": datetime.datetime(2008, 5, 5, 0, 0),
"rule": rule,
"calendar": cal,
}
recurring_event = Event(**data)
recurring_event.save()
self.month = Month(events=Event.objects.all(), date=datetime.datetime(2008, 2, 7, 9, 0))
def test_get_calendar_for_object(self):
user = User(username="******")
user.save()
calendar = Calendar(name='My Cal', slug='My Cal')
calendar.save()
calendar.create_relation(user)
calendar_object = Calendar.objects.get_calendar_for_object(user)
self.assertEqual(calendar_object.slug, 'My Cal')
calendar = Calendar(name='My 2nd Cal')
calendar.save()
try:
calendar.create_relation(user)
except Exception as error:
self.assertRaises(
error, AssertionError("More than one calendars were found."))
def test_recurring_event_get_occurrences_after(self):
cal = Calendar(name="MyCal")
cal.save()
rule = Rule(frequency="WEEKLY")
rule.save()
recurring_event= self.__create_recurring_event(
'Recurrent event test get_occurrence',
datetime.datetime(2008, 1, 5, 8, 0, tzinfo=pytz.utc),
datetime.datetime(2008, 1, 5, 9, 0, tzinfo=pytz.utc),
datetime.datetime(2008, 5, 5, 0, 0, tzinfo=pytz.utc),
rule,
cal,
)
recurring_event.save()
def test_get_absolute(self):
cal = Calendar(name='MyCal')
cal.save()
rule = Rule(frequency = "DAILY")
rule.save()
start = timezone.now() + datetime.timedelta(days=1)
event = self.__create_recurring_event(
'Non recurring event test get_occurrence',
start,
start + datetime.timedelta(hours=1),
start + datetime.timedelta(days=10),
rule,
cal)
event.save()
url = event.get_absolute_url()
self.assertEqual(reverse('event', kwargs={'event_id': event.id}), url)
def test_recurring_event_get_occurrences_after(self):
cal = Calendar(name="MyCal")
cal.save()
rule = Rule(frequency = "WEEKLY")
rule.save()
recurring_event= self.__create_recurring_event(
'Recurrent event test get_occurrence',
datetime.datetime(2008, 1, 5, 8, 0, tzinfo=pytz.utc),
datetime.datetime(2008, 1, 5, 9, 0, tzinfo=pytz.utc),
datetime.datetime(2008, 5, 5, 0, 0, tzinfo=pytz.utc),
rule,
cal,
)
recurring_event.save()
def test_prevent_type_error_when_comparing_naive_and_aware_dates(self):
# this only test if the TypeError is raised
cal = Calendar(name="MyCal")
cal.save()
rule = Rule(frequency = "WEEKLY")
rule.save()
event = self.__create_recurring_event(
'Recurrent event test get_occurrence',
datetime.datetime(2008, 1, 5, 8, 0, tzinfo=pytz.utc),
datetime.datetime(2008, 1, 5, 9, 0, tzinfo=pytz.utc),
datetime.datetime(2008, 5, 5, 0, 0, tzinfo=pytz.utc),
rule,
cal,
)
naive_date = datetime.datetime(2008, 1, 20, 0, 0)
self.assertIsNone(event.get_occurrence(naive_date))
class TestTemplateTags(TestCase):
def setUp(self):
self.day = Day(events=Event.objects.all(), date=datetime.datetime(2008, 2, 7, 0, 0, tzinfo=pytz.utc))
rule = Rule(frequency="WEEKLY")
rule.save()
self.cal = Calendar(name="MyCal", slug="MyCalSlug")
self.cal.save()
data = {
"title": "Recent Event",
"start": datetime.datetime(2008, 1, 5, 8, 0, tzinfo=pytz.utc),
"end": datetime.datetime(2008, 1, 5, 9, 0, tzinfo=pytz.utc),
"end_recurring_period": datetime.datetime(2008, 5, 5, 0, 0, tzinfo=pytz.utc),
"rule": rule,
"calendar": self.cal,
}
recurring_event = Event(**data)
recurring_event.save()
self.period = Period(
events=Event.objects.all(),
start=datetime.datetime(2008, 1, 4, 7, 0, tzinfo=pytz.utc),
end=datetime.datetime(2008, 1, 21, 7, 0, tzinfo=pytz.utc),
)
def test_querystring_for_datetime(self):
date = datetime.datetime(2008, 1, 1, 0, 0, 0)
query_string = querystring_for_date(date, autoescape=True)
self.assertEqual(escape("?year=2008&month=1&day=1&hour=0&minute=0&second=0"), query_string)
def test_prev_url(self):
query_string = prev_url("month_calendar", "MyCalSlug", self.day)
expected = "/calendar/month/MyCalSlug/?year=2008&month=2&day=6&hour=0" "&minute=0&second=0"
self.assertEqual(query_string, escape(expected))
def test_next_url(self):
query_string = next_url("month_calendar", "MyCalSlug", self.day)
expected = "/calendar/month/MyCalSlug/?year=2008&month=2&day=8&hour=0" "&minute=0&second=0"
self.assertEqual(query_string, escape(expected))
def test_create_event_url(self):
context = {}
slot = self.period.get_time_slot(
datetime.datetime(2010, 1, 4, 7, 0, tzinfo=pytz.utc), datetime.datetime(2008, 1, 4, 7, 12, tzinfo=pytz.utc)
)
query_string = create_event_url(context, self.cal, slot.start)
expected = "/event/create/MyCalSlug/?year=2010&month=1&day=4&hour=7" "&minute=0&second=0"
self.assertEqual(query_string["create_event_url"], escape(expected))
def save(request):
try:
sched = Calendar.objects.get(slug=request.POST['slug'])
except Calendar.DoesNotExist:
sched = Calendar()
sched.name = request.POST['name']
sched.slug = request.POST['slug']
try:
sched.save()
return HttpResponseRedirect('/schedules/')
except IntegrityError:
messages.error(request, 'Schedule already exists')
if request.POST['slug']:
return HttpResponseRedirect(reverse('openduty.schedules.edit', None, [request.POST['slug']]))
else:
return HttpResponseRedirect(reverse('openduty.schedules.new'))
def create_club(request, template_name="schedule_tests/clubs/new.html"):
if request.method == 'POST':
form = ClubForm(request.POST)
if form.is_valid():
club = form.save(commit=False)
club.save()
calendar = Calendar(name = "%s Calendar" % club.name, slug = unicode(uuid.uuid1()))
calendar.save()
CalendarRelation.objects.create_relation(calendar, club, distinction="default", inheritable=True)
return HttpResponseRedirect(reverse('show_club', args=(club.id,)))
# if invalid, it gets displayed below
else:
form = ClubForm()
return render_to_response(template_name, {'form': form,},
context_instance=RequestContext(request))
def setUp(self):
rule = Rule(frequency = "WEEKLY")
rule.save()
cal = Calendar(name="MyCal")
cal.save()
data = {
'title': 'Recent Event',
'start': datetime.datetime(2008, 1, 5, 8, 0),
'end': datetime.datetime(2008, 1, 5, 9, 0),
'end_recurring_period' : datetime.datetime(2008, 5, 5, 0, 0),
'rule': rule,
'calendar': cal
}
recurring_event = Event(**data)
recurring_event.save()
self.month = Month(events=Event.objects.all(),
date=datetime.datetime(2008, 2, 7, 9, 0))
def save(self, *args, **kwargs):
if not self.calendar_id:
if self.pk:
self.calendar = Calendar.objects.get_or_create_calendar_for_object(
self)
else:
name = u'Calendar ' + datetime.now().strftime("%Y%m%d-%H%M%S")
calendar = Calendar(name=name)
calendar.slug = slugify(calendar.name)
calendar.save()
self.calendar = calendar
obj = super(Alloggio, self).save(*args, **kwargs)
calendar.create_relation(self)
return obj
return super(Alloggio, self).save(*args, **kwargs)
def test_occurences_with_recurrent_event_end_recurring_period_edge_case(self):
cal = Calendar(name='MyCal')
cal.save()
rule = Rule(frequency="DAILY")
rule.save()
start = timezone.now() + datetime.timedelta(days=1)
event = self.__create_recurring_event(
'Non recurring event test get_occurrence',
start,
start + datetime.timedelta(hours=1),
start + datetime.timedelta(days=10),
rule,
cal)
event.save()
occurrences = list(event.occurrences_after())
self.assertEqual(len(occurrences), 11)
def setUp(self):
rule = Rule(frequency = "WEEKLY")
rule.save()
cal = Calendar(name="MyCal")
cal.save()
data = {
'title': 'Recent Event',
'start': datetime.datetime(2008, 1, 5, 8, 0, tzinfo=pytz.utc),
'end': datetime.datetime(2008, 1, 5, 9, 0, tzinfo=pytz.utc),
'end_recurring_period' : datetime.datetime(2008, 5, 5, 0, 0, tzinfo=pytz.utc),
'rule': rule,
'calendar': cal
}
recurring_event = Event(**data)
recurring_event.save()
self.month = Month(events=Event.objects.all(),
date=datetime.datetime(2008, 2, 7, 9, 0, tzinfo=pytz.utc))
def test_prevent_type_error_when_comparing_naive_and_aware_dates(self):
# this only test if the TypeError is raised
cal = Calendar(name="MyCal")
cal.save()
rule = Rule(frequency="WEEKLY")
rule.save()
event = self.__create_recurring_event(
'Recurrent event test get_occurrence',
datetime.datetime(2008, 1, 5, 8, 0, tzinfo=pytz.utc),
datetime.datetime(2008, 1, 5, 9, 0, tzinfo=pytz.utc),
datetime.datetime(2008, 5, 5, 0, 0, tzinfo=pytz.utc),
rule,
cal,
)
naive_date = datetime.datetime(2008, 1, 20, 0, 0)
self.assertIsNone(event.get_occurrence(naive_date))
def save(request):
try:
sched = Calendar.objects.get(id = request.POST['id'])
except Calendar.DoesNotExist:
sched = Calendar()
sched.name = request.POST['name']
sched.slug = request.POST['slug']
try:
sched.save()
return HttpResponseRedirect('/schedules/');
except IntegrityError:
messages.error(request, 'Schedule already exists')
if int(request.POST['id']) > 0:
return HttpResponseRedirect(reverse('openduty.schedules.edit', None, [str(request.POST['id'])]))
else:
return HttpResponseRedirect(reverse('openduty.schedules.new'))
class TestEventViews(LoggedInTestCase):
def test_event_can_be_recurring(self):
self.cal = Calendar(
name=random_string(),
slug=random_string(),
)
self.cal.save()
self.event = Event.objects.create(
start=timezone.now(),
end=timezone.now() + timedelta(weeks=6),
title=random_string(),
calendar=self.cal,
)
rule = Rule(
name=random_string(),
description=random_string(),
frequency='WEEKLY',
)
rule.save()
assert rule
assert self.event
assert self.cal
assert not self.event.rule
url = reverse(
'edit_event',
kwargs={
'calendar_slug': self.cal.slug,
'event_id': self.event.id,
},
)
response = self.client.post(
path=url,
data={
"start_0": self.event.start.strftime('%Y-%m-%d'),
"start_1": "09:00",
"end_0": self.event.end.strftime('%Y-%m-%d'),
"end_1": "23:00",
"description": "desc",
"rule": rule.id,
"oncall": "foo",
"fallback": "bar",
},
)
self.assertEqual(200, response.status_code)
def setUp(self):
rule = Rule(frequency = "WEEKLY")
rule.save()
cal = Calendar(name="MyCal")
cal.save()
data = {
'title': 'Recent Event',
'start': datetime.datetime(2008, 1, 5, 8, 0, tzinfo=pytz.utc),
'end': datetime.datetime(2008, 1, 5, 9, 0, tzinfo=pytz.utc),
'end_recurring_period' : datetime.datetime(2008, 5, 5, 0, 0, tzinfo=pytz.utc),
'rule': rule,
'calendar': cal
}
recurring_event = Event(**data)
recurring_event.save()
self.period = Period(events=Event.objects.all(),
start = datetime.datetime(2008, 1, 4, 7, 0, tzinfo=pytz.utc),
end = datetime.datetime(2008, 1, 21, 7, 0, tzinfo=pytz.utc))
def setUp(self):
rule = Rule(frequency="WEEKLY")
rule.save()
cal = Calendar(name="MyCal")
cal.save()
data = {
'title': 'Recent Event',
'start': datetime.datetime(2008, 1, 5, 8, 0),
'end': datetime.datetime(2008, 1, 5, 9, 0),
'end_recurring_period': datetime.datetime(2008, 5, 5, 0, 0),
'rule': rule,
'calendar': cal
}
recurring_event = Event(**data)
recurring_event.save()
self.period = Period(events=Event.objects.all(),
start=datetime.datetime(2008, 1, 4, 7, 0),
end=datetime.datetime(2008, 1, 21, 7, 0))
def test_all_day_event_cook_slots(self):
cal = Calendar(name='MyCal', slug='MyCalSlug')
cal.save()
start = datetime.datetime(
datetime.datetime.now().year, 1, 5, 0, 0, tzinfo=pytz.utc)
end = datetime.datetime(
datetime.datetime.now().year, 1, 6, 0, 0, tzinfo=pytz.utc)
data = {
'title': 'All Day Event',
'start': start,
'end': end,
'calendar': self.cal,
}
event = Event(**data)
event.save()
period = Day([event], start, end)
slots = _cook_slots(period, 60)
self.assertEqual(len(slots), 24)
def setUp(self):
rule = Rule(frequency="WEEKLY")
rule.save()
cal = Calendar(name="MyCal")
cal.save()
data = {
"title": "Recent Event",
"start": datetime.datetime(2008, 1, 5, 8, 0, tzinfo=pytz.utc),
"end": datetime.datetime(2008, 1, 5, 9, 0, tzinfo=pytz.utc),
"end_recurring_period": datetime.datetime(2008, 5, 5, 0, 0, tzinfo=pytz.utc),
"rule": rule,
"calendar": cal,
}
recurring_event = Event(**data)
recurring_event.save()
self.period = Period(
events=Event.objects.all(),
start=datetime.datetime(2008, 1, 4, 7, 0, tzinfo=pytz.utc),
end=datetime.datetime(2008, 1, 21, 7, 0, tzinfo=pytz.utc),
)
def test_recurring_event_get_occurrence(self):
cal = Calendar(name="MyCal")
cal.save()
rule = Rule(frequency = "WEEKLY")
rule.save()
event = self.__create_recurring_event(
'Recurrent event test get_occurrence',
datetime.datetime(2008, 1, 5, 8, 0, tzinfo=pytz.utc),
datetime.datetime(2008, 1, 5, 9, 0, tzinfo=pytz.utc),
datetime.datetime(2008, 5, 5, 0, 0, tzinfo=pytz.utc),
rule,
cal,
)
event.save()
occurrence = event.get_occurrence(datetime.datetime(2008, 1, 5, 8, 0, tzinfo=pytz.utc))
self.assertEqual(occurrence.start, datetime.datetime(2008, 1, 5, 8, tzinfo=pytz.utc))
occurrence.save()
occurrence = event.get_occurrence(datetime.datetime(2008, 1, 5, 8, 0, tzinfo=pytz.utc))
self.assertTrue(occurrence.pk is not None)
def create_flat(request):
flat_name = request.data.get('name', None)
if flat_name is None:
return Response(data={
'message': 'Flat name must be defined',
},
status=400)
flat = Flat.objects.create(name=flat_name)
flat.users.add(request.user)
flat.save()
calendar = Calendar(name='flat_{0}'.format(flat.id))
calendar.save()
calendar.create_relation(flat)
return Response(data={
'flat': FlatSerializer(flat).data,
}, status=200)
def test_recurring_event_get_occurrences_2(self):
cal = Calendar(name="MyCal")
cal.save()
rule = Rule(frequency="WEEKLY")
rule.save()
recurring_event = self.__create_recurring_event(
'Recurring event test',
datetime.datetime(2008, 1, 5, 8, 0, tzinfo=pytz.utc),
datetime.datetime(2008, 1, 5, 9, 0, tzinfo=pytz.utc),
datetime.datetime(2008, 5, 5, 0, 0, tzinfo=pytz.utc), rule, cal)
recurring_event.save()
occurrences = recurring_event.get_occurrences(
start=datetime.datetime(2008, 1, 12, 0, 0, tzinfo=pytz.utc),
end=datetime.datetime(2008, 1, 20, 0, 0, tzinfo=pytz.utc))
self.assertEqual(
["%s to %s" % (o.start, o.end) for o in occurrences], [
'2008-01-12 08:00:00+00:00 to 2008-01-12 09:00:00+00:00',
'2008-01-19 08:00:00+00:00 to 2008-01-19 09:00:00+00:00'
])
def test_event_get_occurrences_after(self):
cal = Calendar(name="MyCal")
cal.save()
rule = Rule(frequency="WEEKLY")
rule.save()
recurring_event = self.__create_recurring_event(
'Recurrent event test get_occurrence',
datetime.datetime(2008, 1, 5, 8, 0, tzinfo=pytz.utc),
datetime.datetime(2008, 1, 5, 9, 0, tzinfo=pytz.utc),
datetime.datetime(2008, 5, 5, 0, 0, tzinfo=pytz.utc),
rule,
cal,
)
event_one = self.__create_event(
'Edge case event test one',
datetime.datetime(2013, 1, 5, 8, 0, tzinfo=pytz.utc),
datetime.datetime(2013, 1, 5, 9, 0, tzinfo=pytz.utc),
cal
)
event_two = self.__create_event(
'Edge case event test two',
datetime.datetime(2013, 1, 5, 9, 0, tzinfo=pytz.utc),
datetime.datetime(2013, 1, 5, 12, 0, tzinfo=pytz.utc),
cal
)
event_one.save()
event_two.save()
occurrences_two = event_two.get_occurrences(
datetime.datetime(2013, 1, 5, 9, 0, tzinfo=pytz.utc),
datetime.datetime(2013, 1, 5, 12, 0, tzinfo=pytz.utc))
self.assertEqual(1, len(occurrences_two))
occurrences_one = event_one.get_occurrences(
datetime.datetime(2013, 1, 5, 9, 0, tzinfo=pytz.utc),
datetime.datetime(2013, 1, 5, 12, 0, tzinfo=pytz.utc))
self.assertEqual(0, len(occurrences_one))
def profile(request, username, template_name="profiles/profile.html"):
other_user = get_object_or_404(User, username=username)
profile = other_user.get_profile()
try:
cal = Calendar.objects.get(pk=1)
except Calendar.DoesNotExist:
cal = Calendar(name="Community Calendar")
cal.save()
if request.user.is_authenticated():
if request.user == other_user:
is_me = True
else:
is_me = False
else:
is_me = False
if is_me:
if request.method == "POST":
if request.POST["action"] == "update":
profile_form = ProfileForm(request.POST,
instance=other_user.get_profile())
if profile_form.is_valid():
profile = profile_form.save(commit=False)
profile.user = other_user
profile.save()
else:
profile_form = ProfileForm(instance=other_user.get_profile())
else:
profile_form = ProfileForm(instance=other_user.get_profile())
else:
profile_form = None
return render_to_response(template_name, {
"profile_form": profile_form,
"is_me": is_me,
"other_user": other_user,
"profile": profile,
"calendar": cal,
},
context_instance=RequestContext(request))
def setUp(self):
self.MVD = pytz.timezone('America/Montevideo') # UTC-3
cal = Calendar(name="MyCal")
cal.save()
rule = Rule(frequency="DAILY", name="daily")
rule.save()
data = {
'title':
'Test event',
'start':
self.MVD.localize(datetime.datetime(2017, 1, 13, 15, 0)),
'end':
self.MVD.localize(datetime.datetime(2017, 1, 14, 15, 0)),
'end_recurring_period':
self.MVD.localize(datetime.datetime(2017, 1, 20)),
'rule':
rule,
'calendar':
cal
}
recurring_event = Event(**data)
recurring_event.save()
def setUp(self):
self.MVD = pytz.timezone('America/Montevideo')
cal = Calendar(name="MyCal")
cal.save()
rule = Rule(frequency="DAILY", params="byweekday:SA", name="Saturdays")
rule.save()
data = {
'title':
'Every Saturday Event',
'start':
self.MVD.localize(datetime.datetime(2017, 1, 7, 22, 0)),
'end':
self.MVD.localize(datetime.datetime(2017, 1, 7, 23, 0)),
'end_recurring_period':
self.MVD.localize(datetime.datetime(2017, 2, 1)),
'rule':
rule,
'calendar':
cal
}
recurring_event = Event(**data)
recurring_event.save()
def test_get_occurrences__years_old_events(self):
"""
Test events across year-long boundaries.
TODO(faisal): Time to calculate events within start-end grows with the distance of start
from the first event start. See how to optimize for that in the future
"""
cal = Calendar(name="MyCal")
cal.save()
rule_weekly = Rule(frequency="WEEKLY")
rule_weekly.save()
# Rule that was defined previous year and occurrences are fetched for next year.
event_params = {
'title': 'Edge case event test one',
'start': datetime.datetime(2014, 12, 29, 8, 0, tzinfo=pytz.utc),
'end': datetime.datetime(2014, 12, 29, 8, 0, tzinfo=pytz.utc),
'rule': rule_weekly
}
weekly_point_event = Event.objects.create(**event_params)
occ1 = weekly_point_event.get_occurrences(
datetime.datetime(2015, 1, 5, 8, 0, tzinfo=pytz.utc),
datetime.datetime(2015, 2, 5, 8, 0, tzinfo=pytz.utc))
self.assertEquals(5, len(occ1))
# Rule that was defined several years ago and occurrences are fetched for a much later time
event_params = {
'title': 'Edge case event test one',
'start': datetime.datetime(2009, 11, 02, 8, 0, tzinfo=pytz.utc),
'end': datetime.datetime(2009, 11, 02, 8, 0, tzinfo=pytz.utc),
'rule': rule_weekly
}
event = Event.objects.create(**event_params)
occ2 = event.get_occurrences(
datetime.datetime(2015, 1, 5, 8, 0, tzinfo=pytz.utc),
datetime.datetime(2015, 2, 5, 8, 0, tzinfo=pytz.utc))
self.assertEquals(5, len(occ2))
def test_get_occurrences_is_sorted(self):
rule = Rule(frequency="DAILY")
rule.save()
cal = Calendar(name="MyCal")
cal.save()
recurring_data = {
'title': 'Recent Event',
'start': datetime.datetime(2016, 1, 5, 8, 0, tzinfo=pytz.utc),
'end': datetime.datetime(2016, 1, 5, 9, 0, tzinfo=pytz.utc),
'end_recurring_period': datetime.datetime(2016, 8, 5, 0, 0, tzinfo=pytz.utc),
'rule': rule,
'calendar': cal
}
recurring_event = Event.objects.create(**recurring_data)
start = datetime.datetime(2016, 1, 12, 0, 0, tzinfo=pytz.utc)
end = datetime.datetime(2016, 1, 27, 0, 0, tzinfo=pytz.utc)
occurrences = recurring_event.get_occurrences(start=start, end=end)
sorted_occurrences = sorted(occurrences, key=lambda occ: occ.start)
self.assertEqual(occurrences, sorted_occurrences)
def test_get_for_object(self):
user = User.objects.create_user('john', '*****@*****.**', 'johnpassword')
event_relations = list(Event.objects.get_for_object(user, 'owner', inherit=False))
self.assertEqual(len(event_relations), 0)
rule = Rule(frequency = "DAILY")
rule.save()
cal = Calendar(name='MyCal')
cal.save()
event = self.__create_event(
'event test',
datetime.datetime(2013, 1, 5, 8, 0, tzinfo=pytz.utc),
datetime.datetime(2013, 1, 5, 9, 0, tzinfo=pytz.utc),
cal
)
event.save()
events = list(Event.objects.get_for_object(user, 'owner', inherit=False))
self.assertEqual(len(events), 0)
EventRelation.objects.create_relation(event, user, 'owner')
events = list(Event.objects.get_for_object(user, 'owner', inherit=False))
self.assertEqual(len(events), 1)
self.assertEqual(event, events[0])
def test_recurring_event_with_moved_get_occurrences_after(self):
cal = Calendar(name="MyCal")
cal.save()
rule = Rule(frequency="WEEKLY")
rule.save()
recurring_event = self.__create_recurring_event(
'Recurrent event test get_occurrence',
datetime.datetime(2008, 1, 5, 8, 0, tzinfo=pytz.utc),
datetime.datetime(2008, 1, 5, 9, 0, tzinfo=pytz.utc),
datetime.datetime(2008, 5, 5, 0, 0, tzinfo=pytz.utc),
rule,
cal,
)
recurring_event.save()
occurrence = recurring_event.get_occurrence(
datetime.datetime(2008, 1, 12, 8, 0, tzinfo=pytz.utc))
occurrence.move(datetime.datetime(2008, 1, 15, 8, 0, tzinfo=pytz.utc),
datetime.datetime(2008, 1, 15, 9, 0, tzinfo=pytz.utc))
gen = recurring_event.occurrences_after(
datetime.datetime(2008, 1, 14, 8, 0, tzinfo=pytz.utc))
occurrence2 = next(gen)
self.assertEqual(occurrence, occurrence2)
def setUp(self):
rule = Rule(frequency="WEEKLY")
rule.save()
cal = Calendar(name="MyCal")
cal.save()
self.recurring_data = {
'title': 'Recent Event',
'start': datetime.datetime(2008, 1, 5, 8, 0, tzinfo=pytz.utc),
'end': datetime.datetime(2008, 1, 5, 9, 0, tzinfo=pytz.utc),
'end_recurring_period': datetime.datetime(2008, 5, 5, 0, 0, tzinfo=pytz.utc),
'rule': rule,
'calendar': cal
}
self.data = {
'title': 'Recent Event',
'start': datetime.datetime(2008, 1, 5, 8, 0, tzinfo=pytz.utc),
'end': datetime.datetime(2008, 1, 5, 9, 0, tzinfo=pytz.utc),
'end_recurring_period': datetime.datetime(2008, 5, 5, 0, 0, tzinfo=pytz.utc),
'calendar': cal
}
self.recurring_event = Event.objects.create(**self.recurring_data)
self.start = datetime.datetime(2008, 1, 12, 0, 0, tzinfo=pytz.utc)
self.end = datetime.datetime(2008, 1, 27, 0, 0, tzinfo=pytz.utc)
def save(self, force_insert=False, force_update=False):
new_meeting = False
if not self.id:
new_meeting = True
unique_slugify(
self, "-".join([
self.circle.short_name, self.name,
self.date_and_time.strftime('%Y-%m-%d')
]))
super(Meeting, self).save(force_insert, force_update)
end = self.date_and_time + timedelta(minutes=self.duration)
title = " ".join([self.circle.short_name, self.get_name_display()])
if new_meeting:
event = Event(start=self.date_and_time,
end=end,
title=title,
household_location=self.household_location,
alternate_location=self.alternate_location,
description=self.description)
event.save()
rel = EventRelation.objects.create_relation(event, self)
rel.save()
try:
cal = Calendar.objects.get(pk=1)
except Calendar.DoesNotExist:
cal = Calendar(name="Community Calendar")
cal.save()
cal.events.add(event)
else:
event = Event.objects.get_for_object(self)[0]
event.start = self.date_and_time
event.end = end
event.title = title
event.household_location = self.household_location
event.alternate_location = self.alternate_location
event.description = self.description
event.save()
def handle(self, **options):
from schedule.models import Calendar
from schedule.models import Rule
print("checking for existing data ...")
try:
Calendar.objects.get(name="class_calendar")
print("It looks like you already have loaded the sample data, quitting.")
import sys
sys.exit(1)
except Calendar.DoesNotExist:
print("Sample data not found in db.")
print("Install it...")
print("Create the class calendar. ")
class_calendar = Calendar(name="class_calendar", slug="classCalendar")
class_calendar.save()
print("The class calendar is created")
print("Create some common rules. ")
try:
rule = Rule.objects.get(name="Daily")
except Rule.DoesNotExist:
rule = Rule(frequency="YEARLY", name="Yearly", description="will recur once every Year")
rule.save()
print("YEARLY recurrence created")
rule = Rule(frequency="MONTHLY", name="Monthly", description="will recur once every Month")
rule.save()
print("Monthly recurrence created")
rule = Rule(frequency="WEEKLY", name="Weekly", description="will recur once every Week")
rule.save()
print("Weekly recurrence created")
rule = Rule(frequency="DAILY", name="Daily", description="will recur once every Day")
rule.save()
print("Daily recurrence created")
print("The common rules are installed.")
def test_recurring_event_get_occurrences_after(self):
cal = Calendar(name="MyCal")
cal.save()
rule = Rule(frequency="WEEKLY")
rule.save()
recurring_event = self.__create_recurring_event(
'Recurrent event test get_occurrence',
datetime.datetime(2008, 1, 5, 8, 0, tzinfo=pytz.utc),
datetime.datetime(2008, 1, 5, 9, 0, tzinfo=pytz.utc),
datetime.datetime(2008, 5, 5, 0, 0, tzinfo=pytz.utc),
rule,
cal,
)
recurring_event.save()
occurrences = recurring_event.get_occurrences(
start=datetime.datetime(2008, 1, 5, tzinfo=pytz.utc),
end=datetime.datetime(2008, 1, 6, tzinfo=pytz.utc))
occurrence = occurrences[0]
occurrence2 = next(
recurring_event.occurrences_after(
datetime.datetime(2008, 1, 5, tzinfo=pytz.utc)))
self.assertEqual(occurrence, occurrence2)
class TestSchedulesViews(LoggedInTestCase):
def setUp(self):
super(TestSchedulesViews, self).setUp()
self.cal = Calendar(
name=random_string(),
slug=random_string(),
)
self.cal.save()
def tearDown(self):
super(TestSchedulesViews, self).tearDown()
try:
self.cal.delete()
except Exception:
pass
def test_schedule_detail_view_works_with_query_args(self):
assert self.cal.id
response = self.client.get(
reverse('calendar_details', args=[self.cal.slug]),
{'month': '11', 'year': '2014'},
)
self.assertEqual(response.status_code, 200)
