def test_should_return_true_for_reminder_before_deadline_type_if_today_is_two_days_before_following_deadline(
self):
# same week
today = date(2011, 9, 9)
reminder = Reminder(reminder_mode=ReminderMode.BEFORE_DEADLINE, day=2)
deadline = Deadline(frequency=Week(7), mode="Following")
self.assertTrue(reminder.should_be_send_on(deadline, today))
def test_should_return_false_for_reminder_before_deadline_type_if_today_is_not_two_days_before_deadline(
self):
today = date(2011, 9, 9)
# Sunday deadline
reminder = Reminder(reminder_mode=ReminderMode.BEFORE_DEADLINE, day=1)
deadline = Deadline(frequency=Week(7), mode="That")
self.assertFalse(reminder.should_be_send_on(deadline, today))
def test_should_return_true_for_reminder_after_deadline_type_if_today_is_three_days_after_deadline_2(
self):
# next week
today = date(2011, 9, 13)
reminder = Reminder(reminder_mode=ReminderMode.AFTER_DEADLINE, day=3)
deadline = Deadline(frequency=Week(6), mode="That")
self.assertTrue(reminder.should_be_send_on(deadline, today))
def test_should_return_data_senders_as_sender_list_if_remind_to_mode_is_datasenders_without_submissions(
self):
reminder_and_deadline_dict = {'should_send_reminder_to_all_ds': False}
def getitem(name):
return reminder_and_deadline_dict[name]
data_senders = [{
'name': 'reporter1',
'mobile_number': 'tel1'
}, {
'name': 'reporter2',
'mobile_number': 'tel2'
}, {
'name': 'reporter3',
'mobile_number': 'tel3'
}, {
'name': 'reporter4',
'mobile_number': 'tel4'
}]
today = date(2011, 2, 10)
project = MagicMock(spec=Project)
expected_sender_list = [data_senders[0], data_senders[2]]
project.get_data_senders_without_submissions_for.return_value = expected_sender_list
project.reminder_and_deadline.__getitem__.side_effect = getitem
reminder = Reminder(reminder_mode=ReminderMode.ON_DEADLINE)
self.assertEqual(expected_sender_list,
reminder.get_sender_list(project, today, None))
def test_should_return_true_for_reminder_before_deadline_type_if_today_is_on_weekend(
self):
# Case where deadline is in next week, but reminder is scheduled today
today = date(2011, 9, 11)
reminder = Reminder(reminder_mode=ReminderMode.BEFORE_DEADLINE, day=2)
deadline = Deadline(frequency=Week(2), mode="That")
self.assertTrue(reminder.should_be_send_on(deadline, today))
def _add_reminder_info_to_project(cleaned_data,
project,
organization,
reminder_list=None):
set_deadline = False
if project.reminder_and_deadline.get('has_deadline'):
project.reminder_and_deadline['frequency_period'] = cleaned_data[
'frequency_period']
if cleaned_data['frequency_period'] == 'month':
if project.reminder_and_deadline.get('deadline_week'):
del project['reminder_and_deadline']['deadline_week']
set_deadline = True
project.reminder_and_deadline['deadline_month'] = cleaned_data[
'deadline_month']
else:
if project.reminder_and_deadline.get('deadline_month'):
del project.reminder_and_deadline['deadline_month']
set_deadline = True
project.reminder_and_deadline['deadline_week'] = cleaned_data[
'deadline_week']
if project.reminder_and_deadline.get(
'deadline_type') != cleaned_data['deadline_type']:
set_deadline = True
project.reminder_and_deadline['deadline_type'] = cleaned_data[
'deadline_type']
if reminder_list is None:
reminder_list = Reminder.objects.filter(project_id=project.id)
reminder_list.delete()
if cleaned_data['should_send_reminders_before_deadline']:
Reminder(project_id=project.id,
day=cleaned_data['number_of_days_before_deadline'],
message=cleaned_data['reminder_text_before_deadline'],
reminder_mode=ReminderMode.BEFORE_DEADLINE,
organization=organization).save()
if cleaned_data['should_send_reminders_on_deadline']:
Reminder(project_id=project.id,
day=0,
message=cleaned_data['reminder_text_on_deadline'],
reminder_mode=ReminderMode.ON_DEADLINE,
organization=organization).save()
if cleaned_data['should_send_reminders_after_deadline']:
Reminder(project_id=project.id,
day=cleaned_data['number_of_days_after_deadline'],
message=cleaned_data['reminder_text_after_deadline'],
reminder_mode=ReminderMode.AFTER_DEADLINE,
organization=organization).save()
project.reminder_and_deadline[
'should_send_reminder_to_all_ds'] = not cleaned_data[
'whom_to_send_message']
else:
reminder_list = Reminder.objects.filter(project_id=project.id)
reminder_list.delete()
return project, set_deadline
def test_should_calculate_frequency_period_for_next_deadline_if_reminder_before_deadline(self):
today = date(2011, 2, 10)
project = Mock(spec=Project)
mock_deadline = Mock(spec=Deadline)
project.deadline.return_value = mock_deadline
reminder = Reminder(reminder_mode=ReminderMode.BEFORE_DEADLINE)
reminder.get_sender_list(project, today,None)
mock_deadline.next_deadline.assert_called_once_with(today)
def test_should_create_reminder_log(self):
reminder = Reminder(reminder_mode=ReminderMode.AFTER_DEADLINE, day=2)
dbm_mock = Mock(spec=DatabaseManager)
log = reminder.log(dbm_mock,
'test_project',
datetime.now(),
number_of_sms=10)
self.assertTrue(isinstance(log, ReminderLog))
dbm_mock._save_document.assert_called_once()
def test_should_calculate_frequency_period_for_next_deadline_if_reminder_on_deadline(self):
today = date(2011, 2, 10)
project = Mock(spec=Project)
mock_deadline = Mock(spec=Deadline)
project.deadline.return_value = mock_deadline
reminder = Reminder(reminder_mode=ReminderMode.ON_DEADLINE, remind_to=RemindTo.DATASENDERS_WITHOUT_SUBMISSIONS)
reminder.get_sender_list(project, today,None)
mock_deadline.current_deadline.assert_called_once_with(today)
def test_should_calculate_frequency_period_for_current_deadline_if_reminder_after_deadline(self):
today = date(2011, 2, 10)
project = Mock(spec=Project)
mock_deadline = Mock(spec=Deadline)
project.deadline.return_value = mock_deadline
project.reminder_and_deadline.return_value = {'should_send_reminder_to_all_ds': True, 'has_deadline': True}
reminder = Reminder(reminder_mode=ReminderMode.AFTER_DEADLINE)
reminder.get_sender_list(project, today,None)
mock_deadline.current_deadline.assert_called_once_with(today)
def test_should_return_all_data_senders_as_sender_list_if_remind_to_mode_is_all_datasenders(self):
data_senders = [{'name': 'reporter1', 'mobile_number': 'tel1'},
{'name': 'reporter2', 'mobile_number': 'tel2'},
{'name': 'reporter3', 'mobile_number': 'tel3'},
{'name': 'reporter4', 'mobile_number': 'tel4'}
]
today = date(2011, 2, 10)
project = Mock(spec=Project)
project.get_data_senders.return_value = data_senders
reminder = Reminder(reminder_mode=ReminderMode.ON_DEADLINE)
self.assertEqual(data_senders, reminder.get_sender_list(project, today,None))
def test_should_calculate_frequency_period_for_current_deadline_if_reminder_after_deadline(self):
reminder_and_deadline_dict = {'should_send_reminder_to_all_ds': False, 'has_deadline': True}
def getitem(name):
return reminder_and_deadline_dict[name]
today = date(2011, 2, 10)
project = MagicMock(spec=Project)
mock_deadline = MagicMock(spec=Deadline)
project.deadline.return_value = mock_deadline
project.reminder_and_deadline.__getitem__.side_effect = getitem
reminder = Reminder(reminder_mode=ReminderMode.AFTER_DEADLINE)
reminder.get_sender_list(project, today, None)
mock_deadline.current_deadline.assert_called_once_with(today)
def test_should_return_data_senders_as_sender_list_if_remind_to_mode_is_datasenders_without_submissions(self):
data_senders = [{'name': 'reporter1', 'mobile_number': 'tel1'},
{'name': 'reporter2', 'mobile_number': 'tel2'},
{'name': 'reporter3', 'mobile_number': 'tel3'},
{'name': 'reporter4', 'mobile_number': 'tel4'}
]
today = date(2011, 2, 10)
project = Mock(spec=Project)
expected_sender_list = [data_senders[0], data_senders[2]]
project.get_data_senders_without_submissions_for.return_value = expected_sender_list
reminder = Reminder(reminder_mode=ReminderMode.ON_DEADLINE)
self.assertEqual(expected_sender_list, reminder.get_sender_list(project, today,None))
def manage_reminders(request, project_id):
if request.method == 'GET':
reminders = Reminder.objects.filter(project_id=project_id, voided=False)
return HttpResponse(json.dumps([reminder.to_dict() for reminder in reminders]))
if request.method == 'POST':
reminders = json.loads(request.POST['reminders'])
Reminder.objects.filter(project_id=project_id).delete()
for reminder in reminders:
Reminder(project_id=project_id, day=reminder['day'], message=reminder['message'],
reminder_mode=reminder['reminderMode'], organization=utils.get_organization(request),
remind_to=reminder['targetDataSenders']).save()
return HttpResponse("Reminders has been saved")
def create_reminder(request, project_id):
if is_empty(request.POST['id']):
Reminder(project_id=project_id, day=request.POST.get('day', 0), message=request.POST['message'],
reminder_mode=request.POST['reminder_mode'], remind_to=request.POST['remind_to'],
organization=utils.get_organization(request)).save()
messages.success(request, 'Reminder added successfully')
else:
reminder = Reminder.objects.filter(project_id=project_id, id=request.POST['id'])[0]
reminder.day = request.POST.get('day', 0)
reminder.message = request.POST['message']
reminder.reminder_mode = request.POST['reminder_mode']
reminder.remind_to = request.POST['remind_to']
reminder.save()
messages.success(request, 'Reminder updated successfully')
return HttpResponseRedirect(reverse(reminders, args=[project_id]))
def test_should_return_false_for_reminder_on_deadline_type_if_today_is_not_on_deadline(
self):
today = date(2011, 9, 10)
reminder = Reminder(reminder_mode=ReminderMode.ON_DEADLINE)
deadline = Deadline(frequency=Week(5), mode="That")
self.assertFalse(reminder.should_be_send_on(deadline, today))
def test_should_return_true_if_deadline_is_last_day_of_the_month_and_today_28th_of_february(
self):
today = date(2018, 2, 28)
reminder = Reminder(reminder_mode=ReminderMode.ON_DEADLINE)
deadline = Deadline(frequency=Month(0), mode="That")
self.assertTrue(reminder.should_be_send_on(deadline, today))
