def test_rearrange_episodes_new_schedule(self):
# Next calendar shouldn't appear due to doesn't belong to the active calendar
Schedule.objects.create(
programme=self.programme,
calendar=Calendar.objects.create(),
type="L",
start_dt=utc.localize(datetime.datetime(2015, 1, 3, 16, 0, 0)),
recurrences=recurrence.Recurrence(
rrules=[recurrence.Rule(recurrence.WEEKLY)]))
Schedule.objects.create(
programme=self.programme,
calendar=self.calendar,
type="L",
start_dt=utc.localize(datetime.datetime(2015, 1, 3, 17, 0, 0)),
recurrences=recurrence.Recurrence(
rrules=[recurrence.Rule(recurrence.WEEKLY)]))
# save should call rearrange
# rearrange_programme_episodes(self.programme, pytz.utc.localize(datetime.datetime(2015, 1, 1)))
self.assertListEqual(
[
e.issue_date for e in
self.programme.episode_set.all().order_by('issue_date')[:5]
],
[
utc.localize(datetime.datetime(2015, 1, 1, 14, 0)),
utc.localize(datetime.datetime(2015, 1, 2, 14, 0)),
utc.localize(datetime.datetime(2015, 1, 3, 14, 0)),
# The next schedule doesn't belong to the active_calendar
# utc.localize(datetime.datetime(2015, 1, 3, 16, 0)),
utc.localize(datetime.datetime(2015, 1, 3, 17, 0)),
utc.localize(datetime.datetime(2015, 1, 4, 14, 0)),
])
def test_complete_task_ended_recurrence(self):
myrule = recurrence.Rule(freq=recurrence.DAILY,
dtstart=datetime(2014, 1, 2, 0, 0, 0),
dtend=datetime(2015, 1, 2, 0, 0, 0),
interval=1,
count=1)
pattern = recurrence.Recurrence(rrules=[
myrule,
])
start_at = timezone.make_aware(datetime(2018, 1, 15, 4, 0, 0))
due_at = timezone.make_aware(datetime(2018, 1, 15, 12, 0, 0))
action = Action.objects.create(owner=self.user,
short_description="Test Action",
recurrence=pattern,
start_at=start_at,
due_at=due_at,
context=self.user.context_set.first(),
folder=self.user.folder_set.first())
action.save()
self.assertIs(action.status, action.STATUS_OPEN)
action.status = action.STATUS_COMPLETED
action.save()
self.assertIs(action.status, action.STATUS_COMPLETED)
action_recurrence = ActionRecurrence.objects.get(action=action)
self.assertIs(action_recurrence.action.id, action.id)
self.assertIs(action_recurrence.status, action.STATUS_COMPLETED)
self.assertEqual(action_recurrence.start_at, start_at)
self.assertEqual(action_recurrence.due_at, due_at)
self.assertEqual(action.completed_at,
timezone.make_aware(datetime.now()))
def setUp(self):
all_days_but_today = list(range(7))
all_days_but_today.remove(datetime.today().weekday())
rule_not = recurrence.Rule(recurrence.WEEKLY, byday=all_days_but_today)
rec_not = recurrence.Recurrence(rrules=[rule_not])
self.admin = User.objects.create(email="*****@*****.**",
username="******")
self.team = Team.objects.create(name="celery_team_test",
admin=self.admin)
self.report_not_today = Report.objects.create(
team=self.team, recurrences=rec_not, survey_send_time=time.min)
self.report = Report.objects.create(
team=self.team,
survey_send_time=time.min,
recurrences=recurrence.Recurrence(
rrules=[recurrence.Rule(recurrence.WEEKLY, byday=range(7))]))
def test_event_copy_by_date(self, django_app, planner, event, groups,
volunteer):
managers, planners, volunteers = groups
assign_perm("change_event", volunteer,
event) # test that single user permissions are transferred
response = django_app.get(reverse("core:event_copy",
kwargs={"pk": event.id}),
user=planner)
event_count = Event.objects.all().count()
form = response.form
target_date = datetime.now() + timedelta(days=14)
recurr = recurrence.Recurrence(
dtstart=datetime.now(),
rdates=[target_date],
)
form["start_date"] = datetime.now().date()
form["recurrence"] = str(recurr)
form.submit()
occurrences = recurr.between(datetime.now() - timedelta(days=1),
datetime.now() + timedelta(days=365))
new_event = Event.objects.get(title=event.title,
shifts__start_time__date=target_date)
assert Event.objects.all().count() == event_count + 2
assert Shift.objects.filter(
start_time__date__in=occurrences).count() == 2
self.assert_dates(event, occurrences, volunteers, planners)
assert volunteer.has_perm("change_event", new_event)
assert set(get_groups_with_perms(new_event, ["change_event"])) == set(
get_groups_with_perms(event, ["change_event"]))
class Migration(migrations.Migration):
dependencies = [
('schedules', '0001_initial'),
]
operations = [
migrations.AddField(
model_name='schedule',
name='recurrences',
field=recurrence.fields.RecurrenceField(
default=recurrence.Recurrence(
rrules=[recurrence.Rule(recurrence.WEEKLY)]),
verbose_name='recurrences'),
preserve_default=False,
),
migrations.RunPython(migrate_schedules),
migrations.RemoveField(
model_name='schedule',
name='day',
),
migrations.RemoveField(
model_name='schedule',
name='start_hour',
),
]
def to_recurrence_object(self, recurrence_model):
rrules, exrules, rdates, exdates = [], [], [], []
for rule_model in recurrence_model.rules.filter(
mode=choices.INCLUSION):
rrules.append(rule_model.to_rule_object())
for exrule_model in recurrence_model.rules.filter(
mode=choices.EXCLUSION):
exrules.append(rule_model.to_rule_object())
for rdate_model in recurrence_model.dates.filter(
mode=choices.INCLUSION):
rdates.append(pytz.utc.localize(rdate_model.dt))
for exdate_model in recurrence_model.dates.filter(
mode=choices.EXCLUSION):
exdates.append(pytz.utc.localize(exdate_model.dt))
dtstart = dtend = None
if recurrence_model.dtstart:
dtstart = pytz.utc.localize(recurrence_model.dtstart)
if recurrence_model.dtend:
dtend = pytz.utc.localize(recurrence_model.dtend)
return recurrence.Recurrence(dtstart, dtend, rrules, exrules, rdates,
exdates)
def put(self, request, *args, **kwargs):
team_info = json.loads(request.body.decode('utf-8'))
validator = Validator(team_schema)
if not validator.validate(team_info):
return JsonResponse({'error': validator.errors})
try:
team = Team.objects.get(id=int(self.kwargs['team_id']))
except ObjectDoesNotExist:
return JsonResponse({'error': [{"Team ID": "Team not found for ID in request"}]})
check_scope(request, team)
report = team.report_set.first()
if 'send_time' in team_info:
report.survey_send_time = parser.parse(team_info['send_time']).replace(second=0, microsecond=0)
if 'summary_time' in team_info:
report.summary_send_time = parser.parse(team_info['summary_time']).replace(second=0, microsecond=0)
if 'days_of_week' in team_info:
rule = recurrence.Rule(recurrence.WEEKLY, byday=team_info['days_of_week'])
rec = recurrence.Recurrence(rrules=[rule])
report.recurrences = rec
if 'name' in team_info:
team.name = team_info['name']
report.save()
try:
team.save()
except IntegrityError:
return JsonResponse({'error': {"name": _("team with this name already exists")}})
team_dict = model_to_dict(team, exclude=['users'])
team_dict['report'] = self.report_dict(team)
return JsonResponse({'team': team_dict})
def test_event_to_next_day_copy(self, django_app, planner,
event_to_next_day, groups):
managers, planners, volunteers = groups
response = django_app.get(
reverse("core:event_copy", kwargs={"pk": event_to_next_day.id}),
user=planner,
)
event_count = Event.objects.all().count()
form = response.form
target_date = datetime.now() + timedelta(days=14)
recurr = recurrence.Recurrence(
dtstart=datetime.now(),
rdates=[target_date],
)
form["start_date"] = datetime.now().date()
form["recurrence"] = str(recurr)
form.submit()
occurrences = recurr.between(datetime.now() - timedelta(days=1),
datetime.now() + timedelta(days=365))
assert Event.objects.all().count() == event_count + 2
assert Shift.objects.filter(
start_time__date__in=occurrences).count() == 2
for shift_date in occurrences:
shift = Shift.objects.get(start_time__date=shift_date)
assert shift.event.title == event_to_next_day.title
assert shift.event.get_start_time() == shift.start_time
assert shift.meeting_time.date() == shift.start_time.date()
assert shift.end_time.date(
) == shift.start_time.date() + timedelta(days=1)
assert (volunteers and planners) in get_groups_with_perms(
shift.event, ["view_event"])
assert planners in get_groups_with_perms(shift.event,
["change_event"])
def setUp(self):
self.manager = CalendarManager()
programme = Programme.objects.filter(name="Classic hits").get()
programme.name = "Classic hits - ScheduleUtilsTests"
programme.slug = None
programme.id = programme.pk = None
programme.save()
self.programme = programme
Schedule.objects.get_or_create(
programme=programme,
type='L',
calendar=self.calendar,
recurrences=recurrence.Recurrence(
rrules=[recurrence.Rule(recurrence.DAILY)]),
start_dt=pytz.utc.localize(datetime.datetime(2015, 1, 1, 14, 0,
0)))
for number in range(1, 11):
Episode.objects.create(
title='Episode %s' % number,
programme=programme,
summary='',
season=1,
number_in_season=number,
)
programme.rearrange_episodes(
pytz.utc.localize(datetime.datetime(1970, 1, 1)),
Calendar.get_active())
def make_expired_daily_reccurence(self):
rule = recurrence.Rule(recurrence.DAILY)
return recurrence.Recurrence(
dtstart=timezone.now() - timedelta(days=10),
dtend=timezone.now() - timedelta(days=1),
rrules=[rule]
)
def setUp(self):
self.calendar = Calendar.objects.create(name='Calendar',
is_active=True)
self.recurrences = recurrence.Recurrence(rrules=[
recurrence.Rule(recurrence.WEEKLY,
until=utc.localize(datetime.datetime(2014, 1, 31)))
])
programme = Programme.objects.filter(name="Classic hits").get()
programme.name = "Classic hits 2"
programme.slug = None
programme.id = programme.pk = None
programme.save()
self.programme = programme
self.schedule = Schedule.objects.create(
programme=self.programme,
type='L',
recurrences=self.recurrences,
start_dt=utc.localize(datetime.datetime(2014, 1, 6, 14, 0, 0)),
calendar=self.calendar)
self.episode = Episode.objects.create(
title='Episode 1',
programme=programme,
summary='',
season=1,
number_in_season=1,
)
self.programme.rearrange_episodes(
pytz.utc.localize(datetime.datetime(1970, 1, 1)),
Calendar.get_active())
self.episode.refresh_from_db()
def get_recurrence_rrule(self):
r = recurrence.Recurrence(dtstart=self.start_date,
dtend=datetime(2014, 1, 3, 0, 0, 0),
rrules=[
recurrence.Rule(recurrence.WEEKLY),
])
return r
def test_complete_task_monthly_recurrence(self):
myrule = recurrence.Rule(recurrence.MONTHLY, bymonthday=[1])
pattern = recurrence.Recurrence(dtstart=datetime(2014, 1, 2, 0, 0, 0),
dtend=datetime(2150, 1, 3, 0, 0, 0),
rrules=[
myrule,
])
start_at = timezone.make_aware(datetime(2017, 1, 1, 7, 0, 0))
due_at = timezone.make_aware(datetime(2017, 1, 1, 10, 0, 0))
next_start_at = start_at + timedelta(days=31)
next_due_at = due_at + timedelta(days=31)
action = Action.objects.create(owner=self.user,
short_description="Test Action",
recurrence=pattern,
start_at=start_at,
due_at=due_at,
context=self.user.context_set.first(),
folder=self.user.folder_set.first())
action.save()
self.assertIs(action.status, action.STATUS_OPEN)
action.status = action.STATUS_COMPLETED
action.save()
self.assertIs(action.status, action.STATUS_OPEN)
action_recurrence = ActionRecurrence.objects.get(action=action)
self.assertIs(action_recurrence.action.id, action.id)
self.assertIs(action_recurrence.status, action.STATUS_COMPLETED)
self.assertEqual(action_recurrence.start_at, start_at)
self.assertEqual(action_recurrence.due_at, due_at)
self.assertEqual(action.start_at, next_start_at)
self.assertEqual(action.due_at, next_due_at)
self.assertEqual(action.completed_at, None)
def setUp(self):
self.url = "/pending/"
self.client = Client()
self.pending_event = factory.event(
approval_status=constants.EventApprovalStatus.PENDING.name,
recurrences=recurrence.Recurrence(rrules=[recurrence.Rule(recurrence.DAILY)]),
)
self.pending_event.save()
def test_get_or_create_repetition_episode(self):
transmission = Transmission(
Schedule(slot=self.slot,
type='R',
recurrences=recurrence.Recurrence(
dtstart=datetime.datetime(2015, 1, 1, 14, 30))),
timezone.make_aware(datetime.datetime(2015, 1, 1, 14, 30)))
self.assertEqual(transmission._get_or_create_episode(), self.episode)
def setUp(self):
self.recurrences = recurrence.Recurrence(
dtstart=datetime.datetime(2014, 1, 6, 14, 0, 0),
dtend=datetime.datetime(2014, 1, 31, 14, 0, 0),
rrules=[recurrence.Rule(recurrence.WEEKLY)])
self.schedule = Schedule.objects.create(slot=self.slot,
type='L',
recurrences=self.recurrences)
def test_run_review_notices(self):
self.notice.recurrences = recurrence.Recurrence(
rrules=[recurrence.Rule(recurrence.DAILY)])
self.notice.time = (timezone.localtime(timezone.now()) +
timezone.timedelta(minutes=1)).time()
self.notice.save()
tasks.run_review_notices()
assert Schedule.objects.count() == 1
def setUpTestData(cls):
calendar, created = Calendar.objects.get_or_create(name='Example',
is_active=True)
admin_user = User.objects.create_superuser(username='******',
email='*****@*****.**',
password='******')
cls.recorder_programme, created = Programme.objects.get_or_create(
name='Recorder me',
defaults={
u'synopsis': u'synopsis',
u'language': u'en',
u'photo': u'defaults/example/radio_5.jpg',
u'current_season': 3,
u'category': u'News & Politics',
u'_runtime': 60
})
cls.recorder_schedule, created = Schedule.objects.get_or_create(
programme=cls.recorder_programme,
type='L',
calendar=calendar,
recurrences=recurrence.Recurrence(
rrules=[recurrence.Rule(recurrence.DAILY)]),
start_dt=pytz.utc.localize(datetime.datetime(2015, 1, 1, 14, 0,
0)))
Schedule.objects.get_or_create(
programme=cls.recorder_programme,
type='B',
calendar=calendar,
recurrences=recurrence.Recurrence(
rrules=[recurrence.Rule(recurrence.DAILY)]),
start_dt=pytz.utc.localize(datetime.datetime(2015, 1, 1, 18, 0,
0)))
Episode.objects.get_or_create(title='Episode 2x1',
programme=cls.recorder_programme,
summary="summary",
season=2,
number_in_season=1,
issue_date=pytz.utc.localize(
datetime.datetime(
2015, 1, 1, 14, 0, 0)))
def test_between_time_change_skip(self):
schedule = Schedule(slot=self.slot,
recurrences=recurrence.Recurrence(
dtstart=datetime.datetime(
2018, 3, 24, 2, 30, 0),
rrules=[recurrence.Rule(recurrence.DAILY)]))
between = Transmission.between(datetime.datetime(2018, 3, 25, 0, 0, 0),
datetime.datetime(2018, 3, 25, 5, 0, 0),
schedules=[schedule])
self.assertEqual(list(between), [])
def create_freq_schedule(apps, schema):
Frequency = apps.get_model("qa", "Frequency")
from_ = timezone.datetime(2012, 1, 1, tzinfo=timezone.get_current_timezone())
for f in Frequency.objects.all():
rule = recurrence.Rule(recurrence.DAILY, interval=f.due_interval)
f.recurrences = recurrence.Recurrence(rrules=[rule], dtstart=from_)
f.overdue_interval = max(1, f.overdue_interval - f.nominal_interval)
f.nominal_interval = calc_nominal_interval(f)
f.save()
def test_recurring_event(self):
"""Given a recurring event, Google Calendar payload contains recurrence"""
event = factory.event(recurrences=recurrence.Recurrence(rrules=[recurrence.Rule(recurrence.DAILY)]))
event.save()
with mock.patch('census.google_calendar.get_service', return_value=self.mock_service):
google_calendar.google_publish_event(event)
self.mock_service.events.assert_called_with()
self.mock_events.insert.assert_called_once()
payload = self.mock_events.insert.call_args[1]['body']
self.assertEqual(payload['recurrence'], ['RRULE:FREQ=DAILY'])
def test_impossible_recurrence_after(self):
"""
Testing error calling after and function wrapper to solve it (recurrence_after)
"""
start_dt = datetime.datetime(2014, 1, 20, 14, 0, 0)
until_dt = datetime.datetime(2014, 1, 19, 14, 0, 0)
daily_recurrence = recurrence.Recurrence(
rrules=[recurrence.Rule(recurrence.DAILY, until=until_dt)])
dt = daily_recurrence.after(start_dt, True, dtstart=start_dt)
self.assertEqual(start_dt, dt) # wrong!
self.assertIsNone(
recurrence_after(daily_recurrence, start_dt, start_dt))
def setUp(self):
rule = recurrence.Rule(recurrence.WEEKLY, byday=range(7))
rec = recurrence.Recurrence(rrules=[rule])
self.admin = User.objects.create(email="*****@*****.**",
username="******")
self.team = Team.objects.create(name="celery_team_test",
admin=self.admin)
self.membership = Membership.objects.create(team=self.team,
user=self.admin)
self.report = Report.objects.create(team=self.team,
recurrences=rec,
survey_send_time=time.min)
self.question = Question.objects.create(report=self.report,
text='test')
def setUp(self):
synopsis = '''
This programme has complex schedules to test timezone changes.
Only active between March and October 2017
'''
programme, created = Programme.objects.get_or_create(
name='Timezone',
defaults={
'synopsis': synopsis,
'language': 'en',
'photo': 'defaults/example/radio_1.jpg',
'current_season': 1,
'category': 'News & Politics',
'_runtime': 60,
'start_date': datetime.date(2017, 3, 1),
'end_date': datetime.date(2017, 10, 31),
})
self.cest_schedule, created = Schedule.objects.get_or_create(
programme=programme,
type='L',
calendar=self.calendar,
recurrences=recurrence.Recurrence(rrules=[
recurrence.Rule(recurrence.DAILY,
until=SPAIN_TZ.localize(
datetime.datetime(2017, 3, 27)))
]),
start_dt=SPAIN_TZ.localize(
datetime.datetime(2017, 3, 25, 10, 00, 00)))
self.cet_schedule, created = Schedule.objects.get_or_create(
programme=programme,
type='L',
calendar=self.calendar,
recurrences=recurrence.Recurrence(
rrules=[recurrence.Rule(recurrence.DAILY)], ),
start_dt=SPAIN_TZ.localize(
datetime.datetime(2017, 10, 28, 14, 00, 00)))
def test_between_time_change_stable(self):
schedule = Schedule(slot=self.slot,
recurrences=recurrence.Recurrence(
dtstart=datetime.datetime(
2018, 3, 24, 2, 30, 0),
rrules=[recurrence.Rule(recurrence.DAILY)]))
between = Transmission.between(
timezone.make_aware(datetime.datetime(2018, 3, 24, 0, 0, 0)),
timezone.make_aware(datetime.datetime(2018, 3, 26, 5, 0, 0)),
schedules=[schedule])
self.assertListEqual([(timezone.make_naive(t.start), t.start.tzname())
for t in between],
[(datetime.datetime(2018, 3, 24, 2, 30), 'CET'),
(datetime.datetime(2018, 3, 26, 2, 30), 'CEST')])
def n_weekly(self, weeks=4):
"""Generate a frequency to be performed on the specific day of month
with a 7 day window_start and 7 day window_end"""
rule = recurrence.Rule(freq=recurrence.WEEKLY, interval=weeks)
return models.Frequency(
name="%s weekly" % weeks,
slug="%s-weekly" % weeks,
recurrences=recurrence.Recurrence(
rrules=[rule],
dtstart=timezone.datetime(2012, 1, 1, tzinfo=timezone.utc),
),
window_end=7,
window_start=7,
)
def day_of_month(self, day=1):
"""Generate a frequency to be performed on the specific day of month
with a 7 day window_start and 7 day window_end"""
rule = recurrence.Rule(freq=recurrence.MONTHLY, bymonthday=day)
return models.Frequency(
name="Day of Month",
slug="day-of-month",
recurrences=recurrence.Recurrence(
rrules=[rule],
dtstart=timezone.datetime(2012, 1, 1, tzinfo=timezone.utc),
),
window_end=7,
window_start=7,
)
def test_update_relations(client, biweekly, five_this_morning):
budgeted_date = (five_this_morning - timedelta(days=1)).date()
start_date = five_this_morning.date()
first_occurrence = Income.objects.create(
budgeted=1000.0,
budgeted_date=budgeted_date,
recurrences=recurrence.serialize(biweekly))
updater = UpdateIncomeRelationsMixin()
updater.object = first_occurrence
updater.update_relations(update_series=True)
assert Income.objects.count() == 27
assert Income.objects.order_by(
'budgeted_date').first().budgeted_date == start_date
somewhere_in_the_middle = Income.objects.all()[10]
new_start_date = datetime.combine(somewhere_in_the_middle.budgeted_date,
datetime.min.time())
new_recurrence = recurrence.Recurrence(dtstart=new_start_date,
include_dtstart=False,
rrules=[biweekly])
post_data = {
'budgeted': 1500.0,
'budgeted_date': somewhere_in_the_middle.budgeted_date,
'update_all': 'Yes',
'recurrences': recurrence.serialize(new_recurrence),
'first_occurrence': somewhere_in_the_middle.first_occurrence.id,
}
response = client.post(
reverse('update-income', args=(somewhere_in_the_middle.id, )),
post_data)
assert response.status_code == 302
thousands = Income.objects.filter(budgeted=1000.0)
fifteens = Income.objects.filter(budgeted=1500.0)
assert thousands.count() == 10
assert fifteens.count() == 17
assert first_occurrence.income_set.count() == 9
assert len(set(i.budgeted_date
for i in Income.objects.all())) == Income.objects.count()
def wed(self):
"""Generate a Wed frequency with a 1 day window_start and 1 day window_end"""
rule = recurrence.Rule(
freq=recurrence.WEEKLY,
byday=[recurrence.WE],
)
return models.Frequency(
name="Wed",
slug="wed",
recurrences=recurrence.Recurrence(
rrules=[rule],
dtstart=timezone.datetime(2012, 1, 1, tzinfo=timezone.utc),
),
window_start=1,
window_end=1,
)
def mwf(self):
"""Generate a MWF frequency with a 0 day window_start and 1 day window_end"""
rule = recurrence.Rule(
freq=recurrence.WEEKLY,
byday=[recurrence.MO, recurrence.WE, recurrence.FR],
)
return models.Frequency(
name="MWF",
slug="mwf",
recurrences=recurrence.Recurrence(
rrules=[rule],
dtstart=timezone.datetime(2012, 1, 1, tzinfo=timezone.utc),
),
window_start=0,
window_end=1,
)
