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