def close_cases_assigned_to_checkin(checkin_case, rule):
if checkin_case.type != "checkin":
return CaseRuleActionResult()
blank_properties = {
"assigned_to_primary_checkin_case_id": "",
"is_assigned_primary": "",
"assigned_to_primary_name": "",
"assigned_to_primary_username": "",
}
num_related_updates = 0
for assigned_case in _get_assigned_cases(checkin_case):
num_related_updates += 1
(submission, cases) = update_case(
assigned_case.domain,
assigned_case.case_id,
case_properties=blank_properties,
xmlns=AUTO_UPDATE_XMLNS,
device_id=__name__ + ".close_cases_assigned_to_checkin",
)
rule.log_submission(submission.form_id)
(close_checkin_submission, cases) = update_case(
checkin_case.domain,
checkin_case.case_id,
close=True,
xmlns=AUTO_UPDATE_XMLNS,
device_id=__name__ + ".close_cases_assigned_to_checkin",
)
rule.log_submission(close_checkin_submission.form_id)
return CaseRuleActionResult(
num_closes=1,
num_related_updates=num_related_updates,
)
def test_case_time_zone(self):
reminder = (CaseReminderHandler
.create(self.domain, 'test')
.set_case_criteria_start_condition('participant', 'status', MATCH_EXACT, 'green')
.set_case_criteria_start_date()
.set_case_recipient()
.set_sms_content_type('en')
.set_daily_schedule(fire_time=time(12, 0),
message={'en': 'Hello {case.name}, your test result was normal.'})
.set_stop_condition(max_iteration_count=REPEAT_SCHEDULE_INDEFINITELY)
.set_advanced_options())
reminder.save()
self.assertEqual(self.get_reminders(), [])
with create_test_case(self.domain, 'participant', 'bob', drop_signals=False) as case, \
patch('corehq.apps.reminders.models.CaseReminderHandler.get_now') as now_mock:
self.assertEqual(self.get_reminders(), [])
now_mock.return_value = datetime(2016, 1, 1, 10, 0)
update_case(self.domain, case.case_id,
case_properties={'status': 'green', 'time_zone': 'America/New_York'})
reminder_instance = self.assertOneReminder()
self.assertEqual(reminder_instance.domain, self.domain)
self.assertEqual(reminder_instance.handler_id, reminder.get_id)
self.assertTrue(reminder_instance.active)
self.assertEqual(reminder_instance.start_date, date(2016, 1, 1))
self.assertIsNone(reminder_instance.start_condition_datetime)
self.assertEqual(reminder_instance.next_fire, datetime(2016, 1, 1, 17, 0))
self.assertEqual(reminder_instance.case_id, case.case_id)
self.assertEqual(reminder_instance.schedule_iteration_num, 1)
self.assertEqual(reminder_instance.current_event_sequence_num, 0)
self.assertEqual(reminder_instance.callback_try_count, 0)
def test_agency_user_case_from_voucher_fulfilled_by_id(self):
prescription = self.create_prescription_case()
voucher = self.create_voucher_case(prescription.case_id)
self.assertIsNone(
agency_user_case_from_voucher_fulfilled_by_id(
None,
CaseReminder(domain=self.domain)
)
)
self.assertIsNone(
agency_user_case_from_voucher_fulfilled_by_id(
None,
CaseReminder(domain=self.domain, case_id=voucher.case_id)
)
)
user = CommCareUser.create(self.domain, 'mobile', 'password')
update_case(self.domain, voucher.case_id, case_properties={'voucher_fulfilled_by_id': user.get_id})
with create_user_case(user) as user_case:
self.assertEqual(
agency_user_case_from_voucher_fulfilled_by_id(
None,
CaseReminder(domain=self.domain, case_id=voucher.case_id)
).case_id,
user_case.case_id
)
def test_one_way_numbers(self):
user1 = CommCareUser.create(self.domain, uuid.uuid4().hex, 'abc')
user2 = CommCareUser.create(self.domain, uuid.uuid4().hex, 'abc')
user3 = CommCareUser.create(self.domain, uuid.uuid4().hex, 'abc')
self.addCleanup(user1.delete)
self.addCleanup(user2.delete)
self.addCleanup(user3.delete)
self.assertIsNone(user1.memoized_usercase)
self.assertIsNone(Content.get_two_way_entry_or_phone_number(user1))
with self.create_user_case(user2) as case:
self.assertIsNotNone(user2.memoized_usercase)
self.assertIsNone(Content.get_two_way_entry_or_phone_number(user2))
self.assertIsNone(Content.get_two_way_entry_or_phone_number(case))
with self.create_user_case(user3) as case:
# If the user has no number, the user case's number is used
update_case(self.domain, case.case_id, case_properties={'contact_phone_number': '12345678'})
case = CaseAccessors(self.domain).get_case(case.case_id)
self.assertPhoneEntryCount(1)
self.assertPhoneEntryCount(0, only_count_two_way=True)
self.assertIsNotNone(user3.memoized_usercase)
self.assertEqual(Content.get_two_way_entry_or_phone_number(user3), '12345678')
# If the user has a number, it is used before the user case's number
user3.add_phone_number('87654321')
user3.save()
self.assertPhoneEntryCount(2)
self.assertPhoneEntryCount(0, only_count_two_way=True)
self.assertEqual(Content.get_two_way_entry_or_phone_number(user3), '87654321')
# Referencing the case directly uses the case's phone number
self.assertEqual(Content.get_two_way_entry_or_phone_number(case), '12345678')
def test_host_case_owner_location(self):
with create_test_case(self.domain, 'test-extension-case',
'name') as extension_case:
with create_test_case(self.domain, 'test-host-case',
'name') as host_case:
update_case(self.domain,
host_case.case_id,
case_properties={
'owner_id': self.city_location.location_id
})
set_parent_case(self.domain,
extension_case,
host_case,
relationship='extension')
# Test the recipient is returned correctly
instance = CaseTimedScheduleInstance(
domain=self.domain,
case_id=extension_case.case_id,
recipient_type=CaseScheduleInstanceMixin.
RECIPIENT_TYPE_CUSTOM,
recipient_id='HOST_CASE_OWNER_LOCATION',
)
self.assertIsInstance(instance.recipient, SQLLocation)
self.assertEqual(instance.recipient.location_id,
self.city_location.location_id)
# Test location that does not exist
update_case(self.domain,
host_case.case_id,
case_properties={'owner_id': 'does-not-exist'})
instance = CaseTimedScheduleInstance(
domain=self.domain,
case_id=extension_case.case_id,
recipient_type=CaseScheduleInstanceMixin.
RECIPIENT_TYPE_CUSTOM,
recipient_id='HOST_CASE_OWNER_LOCATION',
)
self.assertIsNone(instance.recipient)
# Test on a case that is not an extension case
instance = CaseTimedScheduleInstance(
domain=self.domain,
case_id=host_case.case_id,
recipient_type=CaseScheduleInstanceMixin.
RECIPIENT_TYPE_CUSTOM,
recipient_id='HOST_CASE_OWNER_LOCATION',
)
self.assertIsNone(instance.recipient)
# Test with case id that doesn't exist
instance = CaseTimedScheduleInstance(
domain=self.domain,
case_id='does-not-exist',
recipient_type=CaseScheduleInstanceMixin.
RECIPIENT_TYPE_CUSTOM,
recipient_id='HOST_CASE_OWNER_LOCATION',
)
self.assertIsNone(instance.recipient)
def test_close_case(self):
with create_test_case(self.domain, 'participant', 'test1', drop_signals=False) as case:
case = self.set_case_property(case, 'contact_phone_number', '99987658765')
case = self.set_case_property(case, 'contact_phone_number_is_verified', '1')
self.assertIsNotNone(self.get_case_verified_number(case))
update_case(self.domain, case.case_id, close=True)
self.assertIsNone(self.get_case_verified_number(case))
def update_single_episode(domain, episode_case):
updater = EpisodeAdherenceUpdate(domain, episode_case)
update_json = updater.update_json()
ledger_updates = updater.ledger_updates()
if update_json:
update_case(domain, episode_case.case_id, update_json,
device_id="%s.%s" % (__name__, 'update_single_episode'))
if ledger_updates:
bulk_update_ledger_cases(domain, ledger_updates)
def update_single_case(self, episode_case):
# updates a single episode_case.
assert episode_case.domain == self.domain
update_json = EpisodeAdherenceUpdate(self.domain,
episode_case).update_json()
if update_json:
update_case(self.domain,
episode_case.case_id,
update_json,
device_id="%s.%s" % (__name__, type(self).__name__))
def test_case_property_start_date_with_start_day_of_week(self):
reminder = (CaseReminderHandler
.create(self.domain, 'test')
.set_case_criteria_start_condition('participant', 'status', MATCH_EXACT, 'green')
.set_case_criteria_start_date(start_date='start_date', start_day_of_week=DAY_MON)
.set_case_recipient()
.set_sms_content_type('en')
.set_daily_schedule(fire_time=time(12, 0),
message={'en': 'Hello {case.name}, your test result was normal.'})
.set_stop_condition(max_iteration_count=30)
.set_advanced_options(use_today_if_start_date_is_blank=False))
reminder.save()
self.assertEqual(self.get_reminders(), [])
with create_test_case(self.domain, 'participant', 'bob', drop_signals=False) as case, \
patch('corehq.apps.reminders.models.CaseReminderHandler.get_now') as now_mock:
self.assertEqual(self.get_reminders(), [])
now_mock.return_value = datetime(2016, 1, 1, 10, 0)
update_case(self.domain, case.case_id,
case_properties={'status': 'green', 'start_date': '2016-01-08'})
reminder_instance = self.assertOneReminder()
self.assertEqual(reminder_instance.domain, self.domain)
self.assertEqual(reminder_instance.case_id, case.case_id)
self.assertEqual(reminder_instance.handler_id, reminder.get_id)
self.assertIsNone(reminder_instance.user_id)
self.assertEqual(reminder_instance.next_fire, datetime(2016, 1, 11, 12, 0))
self.assertTrue(reminder_instance.active)
self.assertEqual(reminder_instance.start_date, date(2016, 1, 8))
self.assertEqual(reminder_instance.schedule_iteration_num, 1)
self.assertEqual(reminder_instance.current_event_sequence_num, 0)
self.assertEqual(reminder_instance.callback_try_count, 0)
self.assertEqual(reminder_instance.start_condition_datetime, datetime(2016, 1, 8))
self.assertEqual(reminder_instance.callback_try_count, 0)
# update start day of week and the schedule should be recalculated
prev_definition = reminder
reminder.set_case_criteria_start_date(start_date='start_date', start_day_of_week=DAY_TUE)
reminder.save(schedule_changed=True, prev_definition=prev_definition)
reminder_instance = self.assertOneReminder()
self.assertEqual(reminder_instance.domain, self.domain)
self.assertEqual(reminder_instance.case_id, case.case_id)
self.assertEqual(reminder_instance.handler_id, reminder.get_id)
self.assertIsNone(reminder_instance.user_id)
self.assertEqual(reminder_instance.next_fire, datetime(2016, 1, 12, 12, 0))
self.assertTrue(reminder_instance.active)
self.assertEqual(reminder_instance.start_date, date(2016, 1, 8))
self.assertEqual(reminder_instance.schedule_iteration_num, 1)
self.assertEqual(reminder_instance.current_event_sequence_num, 0)
self.assertEqual(reminder_instance.callback_try_count, 0)
self.assertEqual(reminder_instance.start_condition_datetime, datetime(2016, 1, 8))
self.assertEqual(reminder_instance.callback_try_count, 0)
def apply_actions(self, case):
properties = {}
close = False
for action in self.automaticupdateaction_set.all():
if action.action == AutomaticUpdateAction.ACTION_UPDATE:
properties[action.property_name] = action.property_value
elif action.action == AutomaticUpdateAction.ACTION_CLOSE:
close = True
update_case(case.domain, case.get_id, case_properties=properties, close=close)
def close_cases_assigned_to_checkin(checkin_case, rule):
"""
For any associated checkin case that matches the rule criteria, the following occurs:
1. For all cases of a given type, find all assigned cases. \
An assigned case is a case for which all of the following are true:
- Case type patient or contact
- Exists in the same domain as the user case
- The case property assigned_to_primary_checkin_case_id equals an associated checkin case's case_id
2. For every assigned case, the following case properties are blanked out (set to ""):
- assigned_to_primary_checkin_case_id
- is_assigned_primary
- assigned_to_primary_name
- assigned_to_primary_username
"""
if checkin_case.type != "checkin":
return CaseRuleActionResult()
blank_properties = {
"assigned_to_primary_checkin_case_id": "",
"is_assigned_primary": "",
"assigned_to_primary_name": "",
"assigned_to_primary_username": "",
}
num_related_updates = 0
for assigned_case_domain, assigned_case_id in _get_assigned_cases(
checkin_case):
num_related_updates += 1
(submission, cases) = update_case(
assigned_case_domain,
assigned_case_id,
case_properties=blank_properties,
xmlns=AUTO_UPDATE_XMLNS,
device_id=__name__ + ".close_cases_assigned_to_checkin",
)
rule.log_submission(submission.form_id)
(close_checkin_submission, cases) = update_case(
checkin_case.domain,
checkin_case.case_id,
close=True,
xmlns=AUTO_UPDATE_XMLNS,
device_id=__name__ + ".close_cases_assigned_to_checkin",
)
rule.log_submission(close_checkin_submission.form_id)
return CaseRuleActionResult(
num_closes=1,
num_related_updates=num_related_updates,
)
def _update_case_from_request(request, domain, update_model):
try:
update = _get_case_update(request, domain, update_model)
except ApiError as e:
if not settings.UNIT_TESTING:
notify_exception(request,
"BETS sent the eNikshay API a bad request.")
return json_response({"error": e.message}, status_code=e.status_code)
update_case(domain, update.case_id, case_properties=update.properties)
return json_response({'status': "success"})
def test_user_recipient(self):
reminder = (CaseReminderHandler
.create(self.domain, 'test')
.set_case_criteria_start_condition('participant', 'status', MATCH_EXACT, 'green')
.set_case_criteria_start_date()
.set_last_submitting_user_recipient()
.set_sms_content_type('en')
.set_daily_schedule(fire_time=time(12, 0), message={'en': "{case.name}'s test result was normal."})
.set_stop_condition(max_iteration_count=REPEAT_SCHEDULE_INDEFINITELY)
.set_advanced_options())
reminder.save()
self.assertEqual(self.get_reminders(), [])
with create_test_case(self.domain, 'participant', 'bob', drop_signals=False) as case, \
patch('corehq.apps.reminders.models.CaseReminderHandler.get_now') as now_mock:
self.assertEqual(self.get_reminders(), [])
now_mock.return_value = datetime(2016, 1, 1, 10, 0)
# There should still be no reminder instance since this is submitted by the system user
update_case(self.domain, case.case_id, case_properties={'status': 'green'})
self.assertEqual(self.get_reminders(), [])
# Update the user id on the case
CaseFactory(self.domain).create_or_update_case(
CaseStructure(
case_id=case.case_id,
attrs={'user_id': self.user.get_id}
)
)
reminder_instance = self.assertOneReminder()
self.assertEqual(reminder_instance.domain, self.domain)
self.assertEqual(reminder_instance.handler_id, reminder.get_id)
self.assertTrue(reminder_instance.active)
self.assertEqual(reminder_instance.start_date, date(2016, 1, 1))
self.assertIsNone(reminder_instance.start_condition_datetime)
self.assertEqual(reminder_instance.next_fire, datetime(2016, 1, 1, 12, 0))
self.assertEqual(reminder_instance.case_id, case.case_id)
self.assertEqual(reminder_instance.schedule_iteration_num, 1)
self.assertEqual(reminder_instance.current_event_sequence_num, 0)
self.assertEqual(reminder_instance.user_id, self.user.get_id)
self.assertEqual(reminder_instance.callback_try_count, 0)
# Set a user_id that does not exist
CaseFactory(self.domain).create_or_update_case(
CaseStructure(
case_id=case.case_id,
attrs={'user_id': 'this-user-id-does-not-exist'}
)
)
self.assertEqual(self.get_reminders(), [])
def test_when_delegate_exists(self):
rule = create_empty_rule(self.domain,
AutomaticUpdateRule.WORKFLOW_CASE_UPDATE)
rule.add_action(CustomActionDefinition,
name='ICDS_ESCALATE_TECH_ISSUE')
with create_case(
self.domain,
'tech_issue',
case_name='New Issue',
update={
'ticket_level': 'block',
'touch_case_date': '2017-06-01',
'block_location_id': 'block_id',
'district_location_id': 'district_id',
'state_location_id': 'state_id',
},
) as tech_issue:
result = rule.run_actions_when_case_matches(tech_issue)
self.assertEqual(result.num_updates, 1)
self.assertEqual(result.num_creates, 1)
self.assertEqual(result.num_related_updates, 0)
tech_issue = CaseAccessors(self.domain).get_case(
tech_issue.case_id)
subcases = tech_issue.get_subcases(index_identifier='parent')
self.assertEqual(len(subcases), 1)
[tech_issue_delegate] = subcases
self.assertEqual(
tech_issue_delegate.get_case_property('change_in_level'), '1')
update_case(self.domain,
tech_issue.case_id,
case_properties={'ticket_level': 'block'})
tech_issue = CaseAccessors(self.domain).get_case(
tech_issue.case_id)
result = rule.run_actions_when_case_matches(tech_issue)
self.assertEqual(result.num_updates, 1)
self.assertEqual(result.num_creates, 0)
self.assertEqual(result.num_related_updates, 1)
tech_issue = CaseAccessors(self.domain).get_case(
tech_issue.case_id)
subcases = tech_issue.get_subcases(index_identifier='parent')
self.assertEqual(len(subcases), 1)
[tech_issue_delegate] = subcases
self.assertEqual(
tech_issue_delegate.get_case_property('change_in_level'), '2')
def apply_actions(self, case):
cases_to_update = defaultdict(dict)
close = False
def _get_case_property_value(current_case, name):
result = current_case.resolve_case_property(name)
if result:
return result[0].value
return None
def _add_update_property(name, value, current_case):
while name.startswith("parent/"):
name = name[7:]
# uses first parent if there are multiple
parent_cases = current_case.get_parent(identifier=DEFAULT_PARENT_IDENTIFIER)
if parent_cases:
current_case = parent_cases[0]
else:
return
cases_to_update[current_case.case_id][name] = value
for action in self.automaticupdateaction_set.all():
if action.action == AutomaticUpdateAction.ACTION_UPDATE:
if action.property_value_type == AutomaticUpdateAction.CASE_PROPERTY:
value = _get_case_property_value(case, action.property_value)
if value is None:
continue
else:
value = action.property_value
if value != _get_case_property_value(case, action.property_name):
_add_update_property(action.property_name, value, case)
elif action.action == AutomaticUpdateAction.ACTION_CLOSE:
close = True
# Update any referenced parent cases
for id, properties in cases_to_update.items():
if id == case.case_id:
continue
update_case(case.domain, id, case_properties=properties, close=False, xmlns=AUTO_UPDATE_XMLNS)
# Update / close the case
properties = cases_to_update[case.case_id]
if close or properties:
update_case(case.domain, case.case_id, case_properties=properties, close=close, xmlns=AUTO_UPDATE_XMLNS)
return close
def handle(self, domain, episode_case_ids, **options):
case_accessor = CaseAccessors(domain)
if not episode_case_ids:
episode_case_ids = case_accessor.get_case_ids_in_domain(type='episode')
for episode_case_id in episode_case_ids:
print(episode_case_id)
episode_case = case_accessor.get_case(episode_case_id)
try:
updater = EpisodeFacilityIDMigration(domain, episode_case)
except ENikshayCaseNotFound:
continue
update_json = updater.update_json()
if update_json:
update_case(domain, episode_case_id, update_json)
def close_cases_assigned_to_checkin(checkin_case, rule):
"""
For any associated checkin case that matches the rule criteria, the following occurs:
1) For all cases of type [x] find all fields where [assigned_to_primary_checkin_case_id] is set
to the case ID of the associated checkin case. These are the assigned cases.
2) For every assigned case, the following case properties are blanked out (set to ""):
- assigned_to_primary_checkin_case_id
- is_assigned_primary
- assigned_to_primary_name
- assigned_to_primary_username
"""
if checkin_case.type != "checkin":
return CaseRuleActionResult()
blank_properties = {
"assigned_to_primary_checkin_case_id": "",
"is_assigned_primary": "",
"assigned_to_primary_name": "",
"assigned_to_primary_username": "",
}
num_related_updates = 0
for assigned_case in _get_assigned_cases(checkin_case):
num_related_updates += 1
(submission, cases) = update_case(
assigned_case.domain,
assigned_case.case_id,
case_properties=blank_properties,
xmlns=AUTO_UPDATE_XMLNS,
device_id=__name__ + ".close_cases_assigned_to_checkin",
)
rule.log_submission(submission.form_id)
(close_checkin_submission, cases) = update_case(
checkin_case.domain,
checkin_case.case_id,
close=True,
xmlns=AUTO_UPDATE_XMLNS,
device_id=__name__ + ".close_cases_assigned_to_checkin",
)
rule.log_submission(close_checkin_submission.form_id)
return CaseRuleActionResult(
num_closes=1,
num_related_updates=num_related_updates,
)
def test_host_case_owner_location(self):
with create_test_case(self.domain, 'test-extension-case', 'name') as extension_case:
with create_test_case(self.domain, 'test-host-case', 'name') as host_case:
update_case(self.domain, host_case.case_id,
case_properties={'owner_id': self.city_location.location_id})
set_parent_case(self.domain, extension_case, host_case, relationship='extension')
# Test the recipient is returned correctly
instance = CaseTimedScheduleInstance(
domain=self.domain,
case_id=extension_case.case_id,
recipient_type=CaseScheduleInstanceMixin.RECIPIENT_TYPE_CUSTOM,
recipient_id='HOST_CASE_OWNER_LOCATION',
)
self.assertIsInstance(instance.recipient, SQLLocation)
self.assertEqual(instance.recipient.location_id, self.city_location.location_id)
# Test location that does not exist
update_case(self.domain, host_case.case_id, case_properties={'owner_id': 'does-not-exist'})
instance = CaseTimedScheduleInstance(
domain=self.domain,
case_id=extension_case.case_id,
recipient_type=CaseScheduleInstanceMixin.RECIPIENT_TYPE_CUSTOM,
recipient_id='HOST_CASE_OWNER_LOCATION',
)
self.assertIsNone(instance.recipient)
# Test on a case that is not an extension case
instance = CaseTimedScheduleInstance(
domain=self.domain,
case_id=host_case.case_id,
recipient_type=CaseScheduleInstanceMixin.RECIPIENT_TYPE_CUSTOM,
recipient_id='HOST_CASE_OWNER_LOCATION',
)
self.assertIsNone(instance.recipient)
# Test with case id that doesn't exist
instance = CaseTimedScheduleInstance(
domain=self.domain,
case_id='does-not-exist',
recipient_type=CaseScheduleInstanceMixin.RECIPIENT_TYPE_CUSTOM,
recipient_id='HOST_CASE_OWNER_LOCATION',
)
self.assertIsNone(instance.recipient)
def test_prescription_voucher_alert(self):
prescription = self.create_prescription_case()
voucher = self.create_voucher_case(prescription.case_id)
update_case(self.domain, voucher.case_id, {'voucher_id': '012345'})
update_case(self.domain, self.person_id, {
'name': 'Joe',
'person_id': '123-456-789'
})
self._test_prescription_voucher_alert_with_language(
voucher, None,
"Drug Voucher ID 012345 issued to Joe with Beneficiary ID 123-456-789."
)
self._test_prescription_voucher_alert_with_language(
voucher, "en",
"Drug Voucher ID 012345 issued to Joe with Beneficiary ID 123-456-789."
)
self._test_prescription_voucher_alert_with_language(
voucher, "bho",
"\u0921\u094d\u0930\u0917 \u0935\u093e\u0909\u091a\u0930 \u0906\u0908\u0921\u0940 012345"
" \u092f\u0947 \u0932\u093e\u092d\u093e\u0930\u094d\u0925\u0940 \u0906\u0908\u0921\u0940 "
"123-456-789 \u0915\u0947 \u0938\u0902\u0917\u0947 Joe \u0915\u0947 \u091c\u093e\u0930\u0940 "
"\u0915 \u0926\u0947\u0939\u0932 \u0917\u0908\u0932 \u092c\u093e")
self._test_prescription_voucher_alert_with_language(
voucher, "guj",
"\u0ab2\u0abe\u0aad\u0abe\u0ab0\u0acd\u0aa5\u0ac0 \u0a86\u0a88\u0aa1\u0ac0 123-456-789"
" \u0aa7\u0ab0\u0abe\u0ab5\u0aa4\u0abe Joe \u0aa8\u0ac7 \u0aa1\u0acd\u0ab0\u0a97 "
"\u0ab5\u0abe\u0a89\u0a9a\u0ab0 \u0a86\u0a88\u0aa1\u0ac0 012345 \u0a88\u0ab6\u0acd\u0aaf\u0ac1 "
"\u0a95\u0ab0\u0ab5\u0abe\u0aae\u0abe\u0a82 \u0a86\u0ab5\u0acd\u0aaf\u0ac1\u0a82 \u0a9b\u0ac7."
)
self._test_prescription_voucher_alert_with_language(
voucher, "hin",
"\u0926\u0935\u093e \u0935\u093e\u0909\u091a\u0930 \u0906\u0908\u0921\u0940 012345"
" \u0932\u093e\u092d\u093e\u0930\u094d\u0925\u0940 \u0906\u0908\u0921\u0940 123-456-789 "
"\u0915\u0947 \u0938\u093e\u0925 Joe \u0915\u094b \u091c\u093e\u0930\u0940 \u0915\u093f\u092f\u093e "
"\u0917\u092f\u093e \u0939\u0948\u0964")
self._test_prescription_voucher_alert_with_language(
voucher, "mar",
"123-456-789 \u0939\u093e \u0932\u093e\u092d\u0927\u093e\u0930\u0915\u0906\u092f\u0921\u0940 "
"\u0905\u0938\u0932\u0947\u0932\u094d\u092f\u093e Joe \u0935\u094d\u092f\u0915\u094d\u0924\u0940"
"\u0932\u093e\u0921\u094d\u0930\u0917\u0935\u094d\u0939\u093e\u090a\u091a\u0930\u0906\u092f\u0921"
"\u0940 012345 \u0926\u0947\u0923\u094d\u092f\u093e\u0924 \u0906\u0932\u093e \u0906\u0939\u0947."
)
def handle_response(self, response, repeat_record):
attempt = super().handle_response(response, repeat_record)
# successful response is always 204
if response.status_code == 204:
cowin_api_data_vaccination_case = repeat_record.repeater.payload_doc(
repeat_record)
person_case_id = cowin_api_data_vaccination_case.get_case_property(
"person_case_id")
dose_number = cowin_api_data_vaccination_case.get_case_property(
"dose")
# Ideally person case id should always be present
# Simply ignore cases that don't have that and don't try again
if person_case_id:
update_case(
self.domain,
person_case_id,
case_properties={f'dose_{dose_number}_notified': True},
device_id=__name__ + '.BeneficiaryVaccinationRepeater')
return attempt
def test_ignoring_entries(self):
with create_case(self.domain, 'person') as case:
update_case(self.domain, case.case_id,
case_properties={'contact_phone_number': '12345', 'contact_phone_number_is_verified': '1'})
self.assertPhoneEntryCount(1)
self.assertPhoneEntryCount(1, only_count_two_way=True)
with patch('corehq.apps.sms.tasks.use_phone_entries') as patch1, \
patch('corehq.messaging.tasks.use_phone_entries') as patch2, \
patch('corehq.messaging.scheduling.models.abstract.use_phone_entries') as patch3:
patch1.return_value = patch2.return_value = patch3.return_value = False
update_case(self.domain, case.case_id, case_properties={'contact_phone_number': '23456'})
case = CaseAccessors(self.domain).get_case(case.case_id)
self.assertPhoneEntryCount(1)
self.assertPhoneEntryCount(1, only_count_two_way=True)
self.assertTwoWayEntry(PhoneNumber.objects.get(owner_id=case.case_id), '12345')
self.assertEqual(Content.get_two_way_entry_or_phone_number(case), '23456')
def setUpClass(cls):
super(CustomContentTest, cls).setUpClass()
cls.mother_person_case = cls.create_case('person')
cls.child_person_case = cls.create_case('person',
cls.mother_person_case.case_id,
cls.mother_person_case.type,
'mother',
'child',
case_name="Joe")
cls.child_health_extension_case = cls.create_case(
'child_health', cls.child_person_case.case_id,
cls.child_person_case.type, 'parent', 'extension')
update_case(
cls.domain,
cls.mother_person_case.case_id,
{'language_code': 'en'},
)
cls.mother_person_case = CaseAccessors(cls.domain).get_case(
cls.mother_person_case.case_id)
def test_parent_case_property_criteria(self):
reminder = (CaseReminderHandler
.create(self.domain, 'test')
.set_case_criteria_start_condition('participant', 'parent/status', MATCH_EXACT, 'green')
.set_case_criteria_start_date()
.set_case_recipient()
.set_sms_content_type('en')
.set_daily_schedule(fire_time=time(12, 0),
message={'en': 'Hello {case.name}, your test result was normal.'})
.set_stop_condition(max_iteration_count=REPEAT_SCHEDULE_INDEFINITELY)
.set_advanced_options())
reminder.active = False
reminder.save()
self.assertEqual(self.get_reminders(), [])
with create_test_case(self.domain, 'participant', 'bob', drop_signals=False) as child_case, \
create_test_case(self.domain, 'parent-case', 'jim', drop_signals=False) as parent_case, \
patch('corehq.apps.reminders.models.CaseReminderHandler.get_now') as now_mock:
process_handlers_for_case_changed(self.domain, child_case.case_id, [reminder._id])
self.assertEqual(self.get_reminders(), [])
set_parent_case(self.domain, child_case, parent_case)
process_handlers_for_case_changed(self.domain, child_case.case_id, [reminder._id])
self.assertEqual(self.get_reminders(), [])
now_mock.return_value = datetime(2016, 1, 1, 10, 0)
update_case(self.domain, child_case.case_id, case_properties={'status': 'green'})
self.assertEqual(self.get_reminders(), [])
update_case(self.domain, child_case.case_id, case_properties={'status': ''})
self.assertEqual(self.get_reminders(), [])
update_case(self.domain, parent_case.case_id, case_properties={'status': 'green'})
process_handlers_for_case_changed(self.domain, child_case.case_id, [reminder._id])
reminder_instance = self.assertOneReminder()
self.assertEqual(reminder_instance.domain, self.domain)
self.assertEqual(reminder_instance.handler_id, reminder.get_id)
self.assertFalse(reminder_instance.active)
self.assertEqual(reminder_instance.start_date, date(2016, 1, 1))
self.assertIsNone(reminder_instance.start_condition_datetime)
self.assertEqual(reminder_instance.next_fire, datetime(2016, 1, 1, 12, 0))
self.assertEqual(reminder_instance.case_id, child_case.case_id)
self.assertEqual(reminder_instance.schedule_iteration_num, 1)
self.assertEqual(reminder_instance.current_event_sequence_num, 0)
self.assertEqual(reminder_instance.callback_try_count, 0)
update_case(self.domain, parent_case.case_id, case_properties={'status': 'red'})
process_handlers_for_case_changed(self.domain, child_case.case_id, [reminder._id])
self.assertEqual(self.get_reminders(), [])
def test_beneficiary_registration_recipients(self):
located_in_mehsana.clear(self.phi)
self.dto.site_code = LOCATION_SITE_CODE_MEHSANA
self.dto.save()
self.assign_person_to_location(self.phi.location_id)
update_case(self.domain, self.person_id, case_properties={'fo': self.pcc.location_id})
user = CommCareUser.create(self.domain, 'mobile', 'password', location=self.pcc)
# No user case created yet
result = beneficiary_registration_recipients(
None,
CaseReminder(domain=self.domain, case_id=self.person_id)
)
self.assertTrue(isinstance(result, CommCareCaseSQL))
self.assertEqual(result.case_id, self.person_id)
# Create user case
with create_user_case(user) as user_case:
result = beneficiary_registration_recipients(
None,
CaseReminder(domain=self.domain, case_id=self.person_id)
)
self.assertTrue(isinstance(result, list))
self.assertEqual(
[case.case_id for case in result],
[self.person_id, user_case.case_id]
)
# Test location outside Mehsana
located_in_mehsana.clear(self.phi)
self.dto.site_code = 'dto-other'
self.dto.save()
result = beneficiary_registration_recipients(
None,
CaseReminder(domain=self.domain, case_id=self.person_id)
)
self.assertTrue(isinstance(result, CommCareCaseSQL))
self.assertEqual(result.case_id, self.person_id)
def _update_existing_tech_issue_delegate(tech_issue_delegate):
if tech_issue_delegate.get_case_property('change_in_level') == '1':
change_in_level = '2'
else:
change_in_level = '1'
return update_case(
tech_issue_delegate.domain,
tech_issue_delegate.case_id,
case_properties={'change_in_level': change_in_level},
close=False,
xmlns=AUTO_UPDATE_XMLNS,
)
def handle_response(self, response, repeat_record):
attempt = super().handle_response(response, repeat_record)
# successful response is always 200. 40x and 500 are errors
if response.status_code == 200:
cowin_api_data_registration_case = repeat_record.repeater.payload_doc(
repeat_record)
person_case_id = cowin_api_data_registration_case.get_case_property(
"person_case_id")
# Ideally person case id should always be present
# Simply ignore cases that don't have that and don't try again
if person_case_id:
beneficiary_reference_id = response.json(
)['beneficiary_reference_id']
update_case(self.domain,
person_case_id,
case_properties={
'cowin_beneficiary_reference_id':
beneficiary_reference_id
},
device_id=__name__ +
'.BeneficiaryRegistrationRepeater')
return attempt
def test_not_using_phone_entries(self):
with patch('corehq.apps.sms.tasks.use_phone_entries') as patch1, \
patch('corehq.messaging.tasks.use_phone_entries') as patch2, \
patch('corehq.messaging.scheduling.models.abstract.use_phone_entries') as patch3:
patch1.return_value = patch2.return_value = patch3.return_value = False
user1 = CommCareUser.create(self.domain, uuid.uuid4().hex, 'abc')
user2 = CommCareUser.create(self.domain, uuid.uuid4().hex, 'abc')
user3 = CommCareUser.create(self.domain, uuid.uuid4().hex, 'abc')
self.addCleanup(user1.delete)
self.addCleanup(user2.delete)
self.addCleanup(user3.delete)
self.assertIsNone(user1.memoized_usercase)
self.assertIsNone(Content.get_two_way_entry_or_phone_number(user1))
with self.create_user_case(user2) as case:
self.assertIsNotNone(user2.memoized_usercase)
self.assertIsNone(Content.get_two_way_entry_or_phone_number(user2))
self.assertIsNone(Content.get_two_way_entry_or_phone_number(case))
with self.create_user_case(user3) as case:
# If the user has no number, the user case's number is used
update_case(self.domain, case.case_id, case_properties={'contact_phone_number': '12345678'})
case = CaseAccessors(self.domain).get_case(case.case_id)
self.assertPhoneEntryCount(0)
self.assertIsNotNone(user3.memoized_usercase)
self.assertEqual(Content.get_two_way_entry_or_phone_number(user3), '12345678')
# If the user has a number, it is used before the user case's number
user3.add_phone_number('87654321')
user3.save()
self.assertPhoneEntryCount(0)
self.assertEqual(Content.get_two_way_entry_or_phone_number(user3), '87654321')
# Referencing the case directly uses the case's phone number
self.assertEqual(Content.get_two_way_entry_or_phone_number(case), '12345678')
def _update_existing_tech_issue_delegate(tech_issue_delegate):
if tech_issue_delegate.get_case_property('change_in_level') == '1':
change_in_level = '2'
else:
change_in_level = '1'
return update_case(
tech_issue_delegate.domain,
tech_issue_delegate.case_id,
case_properties={'change_in_level': change_in_level},
close=False,
xmlns=AUTO_UPDATE_XMLNS,
device_id=__name__ + "._update_existing_tech_issue_delegate",
)
def test_close_case(self):
extra_number = PhoneNumber.objects.create(
domain=self.domain,
owner_doc_type='X',
owner_id='X',
phone_number='999123',
verified=True,
pending_verification=False,
is_two_way=True
)
self.assertEqual(PhoneNumber.count_by_domain(self.domain), 1)
with create_test_case(self.domain, 'participant', 'test1', drop_signals=False) as case:
case = self.set_case_property(case, 'contact_phone_number', '99987658765')
case = self.set_case_property(case, 'contact_phone_number_is_verified', '1')
self.assertIsNotNone(self.get_case_phone_number(case))
self.assertEqual(PhoneNumber.count_by_domain(self.domain), 2)
update_case(self.domain, case.case_id, close=True)
self.assertIsNone(self.get_case_phone_number(case))
self.assertEqual(PhoneNumber.count_by_domain(self.domain), 1)
self.assertEqual(PhoneNumber.get_two_way_number('999123'), extra_number)
def _update_tech_issue_for_escalation(case, escalated_ticket_level):
today = ServerTime(datetime.utcnow()).user_time(pytz.timezone('Asia/Kolkata')).done().date()
return update_case(
case.domain,
case.case_id,
case_properties={
'ticket_level': escalated_ticket_level,
'change_in_level': '1',
'touch_case_date': today.strftime('%Y-%m-%d'),
},
close=False,
xmlns=AUTO_UPDATE_XMLNS,
device_id=__name__ + "._update_tech_issue_for_escalation",
)
def sanitize_session_peer_rating(session_case, rule):
"""
For any session case
sanitize the peer_rating metrics based on child cases of type peer_rating
"""
if session_case.type != SESSION_CASE_TYPE:
return CaseRuleActionResult()
peer_rating_cases = _get_peer_rating_cases(session_case)
num_updates = 0
if peer_rating_cases:
case_updates = _get_case_updates(peer_rating_cases)
(submission, cases) = update_case(
session_case.domain,
session_case.case_id,
case_properties=case_updates,
xmlns=AUTO_UPDATE_XMLNS,
device_id=__name__ + ".sanitize_session_peer_rating",
)
num_updates = 1
rule.log_submission(submission.form_id)
return CaseRuleActionResult(num_updates=num_updates, )
def test_host_case_owner_location(self):
parent_location = SQLLocation.objects.create(
domain=self.domain,
name='parent test',
site_code='parent',
location_type=self.parent_location_type)
self.addCleanup(parent_location.delete)
child_location = SQLLocation.objects.create(
domain=self.domain,
name='child test',
site_code='child',
location_type=self.child_location_type,
parent=parent_location)
self.addCleanup(child_location.delete)
with create_test_case(self.domain, 'test-extension-case',
'name') as extension_case:
with create_test_case(self.domain, 'test-host-case',
'name') as host_case:
update_case(
self.domain,
host_case.case_id,
case_properties={'owner_id': child_location.location_id})
set_parent_case(self.domain,
extension_case,
host_case,
relationship='extension')
handler1 = CaseReminderHandler(
domain=self.domain, recipient='HOST_CASE_OWNER_LOCATION')
handler2 = CaseReminderHandler(
domain=self.domain,
recipient='HOST_CASE_OWNER_LOCATION_PARENT')
reminder = CaseReminder(domain=self.domain,
case_id=extension_case.case_id)
# Test the recipients are returned correctly
with patch('corehq.apps.reminders.models.CaseReminder.handler',
new=handler1):
self.assertEqual(reminder.recipient, [child_location])
with patch('corehq.apps.reminders.models.CaseReminder.handler',
new=handler2):
self.assertEqual(reminder.recipient, [parent_location])
# Remove parent location reference
child_location.parent = None
child_location.save()
with patch('corehq.apps.reminders.models.CaseReminder.handler',
new=handler2):
self.assertIsNone(reminder.recipient)
# Test location that does not exist
update_case(self.domain,
host_case.case_id,
case_properties={'owner_id': 'does-not-exist'})
with patch('corehq.apps.reminders.models.CaseReminder.handler',
new=handler1):
self.assertIsNone(reminder.recipient)
# Test on a case that is not an extension case
reminder.case_id = host_case.case_id
with patch('corehq.apps.reminders.models.CaseReminder.handler',
new=handler1):
self.assertIsNone(reminder.recipient)
# Test on a blank case id
reminder.case_id = None
with patch('corehq.apps.reminders.models.CaseReminder.handler',
new=handler1):
self.assertIsNone(reminder.recipient)
def test_is_contact_active_for_case(self):
with create_test_case(self.domain, "contact", "test-case") as case:
self.assertTrue(is_contact_active(self.domain, "CommCareCase", case.case_id))
update_case(self.domain, case.case_id, close=True)
self.assertFalse(is_contact_active(self.domain, "CommCareCase", case.case_id))
def update_single_episode(domain, episode_case):
update_json = EpisodeAdherenceUpdate(domain, episode_case).update_json()
if update_json:
update_case(domain, episode_case.case_id, update_json,
device_id="%s.%s" % (__name__, 'update_single_episode'))
def test_static_negative_growth_indicator(self):
c = CustomContent(
custom_content_id='ICDS_STATIC_NEGATIVE_GROWTH_MESSAGE')
schedule_instance = CaseTimedScheduleInstance(
domain=self.domain,
case_id=self.child_health_case.case_id,
)
# Test when current weight is greater than previous
submit_growth_form(self.domain, self.child_health_case.case_id, '10.1',
'10.4')
self.assertEqual(
c.get_list_of_messages(self.mother_person_case, schedule_instance),
[])
# Test when current weight is equal to previous
submit_growth_form(self.domain, self.child_health_case.case_id, '10.1',
'10.1')
self.assertEqual(
c.get_list_of_messages(self.mother_person_case, schedule_instance),
[
"As per the latest records of your AWC, the weight of your child Joe has remained static in the last "
"month. Please consult your AWW for necessary advice."
])
# Test when current weight is less than previous
submit_growth_form(self.domain, self.child_health_case.case_id, '10.1',
'9.9')
self.assertEqual(
c.get_list_of_messages(self.mother_person_case, schedule_instance),
[
"As per the latest records of your AWC, the weight of your child Joe has reduced in the last month. "
"Please consult your AWW for necessary advice."
])
# Test ignoring forms with the wrong xmlns
update_case(self.domain, self.child_health_case.case_id,
{'property': 'value1'})
update_case(self.domain, self.child_health_case.case_id,
{'property': 'value2'})
update_case(self.domain, self.child_health_case.case_id,
{'property': 'value3'})
update_case(self.domain, self.child_health_case.case_id,
{'property': 'value4'})
update_case(self.domain, self.child_health_case.case_id,
{'property': 'value5'})
update_case(self.domain, self.child_health_case.case_id,
{'property': 'value6'})
update_case(self.domain, self.child_health_case.case_id,
{'property': 'value7'})
update_case(self.domain, self.child_health_case.case_id,
{'property': 'value8'})
update_case(self.domain, self.child_health_case.case_id,
{'property': 'value9'})
update_case(self.domain, self.child_health_case.case_id,
{'property': 'value10'})
self.assertEqual(
c.get_list_of_messages(self.mother_person_case, schedule_instance),
[
"As per the latest records of your AWC, the weight of your child Joe has reduced in the last month. "
"Please consult your AWW for necessary advice."
])
def set_case_property(self, case, property_name, value):
update_case(self.domain, case.case_id, case_properties={property_name: value})
return CaseAccessors(self.domain).get_case(case.case_id)
def test_all_inbound(self):
# Mobile worker creates a case
incoming("999123", "reg", "TEST")
self.assertLastOutboundSMSEquals(self.user1, "Enter Participant ID")
incoming("999123", "pid1234", "TEST")
self.assertLastOutboundSMSEquals(self.user1, "Enter Study Arm 1:a, 2:b.")
incoming("999123", "1", "TEST")
form = self.get_last_form_submission()
self.assertFormQuestionEquals(form, "participant_id", "pid1234")
self.assertFormQuestionEquals(form, "arm", "arm_a")
self.assertFormQuestionEquals(form, "external_id", "pid1234")
case = self.get_case("pid1234")
self.assertIsNotNone(case)
self.assertCasePropertyEquals(case, "name", "pid1234")
self.assertCasePropertyEquals(case, "arm", "arm_a")
# Mobile worker modifies a case
incoming("999123", "mod pid1234", "TEST")
self.assertLastOutboundSMSEquals(self.user1, "Enter Study Arm 1:a, 2:b.")
incoming("999123", "b", "TEST")
form = self.get_last_form_submission()
self.assertFormQuestionEquals(form, "arm", "arm_b")
case = self.get_case("pid1234")
self.assertIsNotNone(case)
self.assertCasePropertyEquals(case, "arm", "arm_b")
# now take the case away from the user
self.update_case_owner(case, self.user3)
case = self.get_case("pid1234")
# then they should no longer have access
incoming("999123", "mod pid1234", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_message(MSG_CASE_NOT_FOUND))
# now add access back via parent connection
self.add_parent_access(self.user1, case)
incoming("999123", "mod pid1234", "TEST")
self.assertLastOutboundSMSEquals(self.user1, "Enter Study Arm 1:a, 2:b.")
incoming("999123", "a", "TEST")
form = self.get_last_form_submission()
self.assertFormQuestionEquals(form, "arm", "arm_a")
case = self.get_case("pid1234")
self.assertIsNotNone(case)
self.assertCasePropertyEquals(case, "arm", "arm_a")
form = self.get_last_form_submission()
# Bad external id
incoming("999123", "mod pid1235", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_message(MSG_CASE_NOT_FOUND))
self.assertNoNewSubmission(form)
# No external id
incoming("999123", "mod", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_message(MSG_MISSING_EXTERNAL_ID))
self.assertNoNewSubmission(form)
# Test validation on all fields
incoming("999123", "Validation_Test", "TEST")
session = self.get_open_session(self.user1)
sms = self.assertLastOutboundSMSEquals(self.user1, "text")
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
sms = incoming("999123", "ab", "TEST")
self.assertTrue(sms.invalid_survey_response)
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
sms = self.assertLastOutboundSMSEquals(self.user1, 'Expected "abc"')
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
sms = incoming("999123", "abc", "TEST")
self.assertFalse(sms.invalid_survey_response)
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
sms = self.assertLastOutboundSMSEquals(self.user1, "single select 1:a, 2:b, 3:c, 4:d.")
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
sms = incoming("999123", "x", "TEST")
self.assertTrue(sms.invalid_survey_response)
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
sms = self.assertLastOutboundSMSEquals(self.user1, "%s single select 1:a, 2:b, 3:c, 4:d." % get_message(MSG_INVALID_CHOICE))
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
sms = incoming("999123", "5", "TEST")
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
sms = self.assertLastOutboundSMSEquals(self.user1, "%s single select 1:a, 2:b, 3:c, 4:d." % get_message(MSG_CHOICE_OUT_OF_RANGE))
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
sms = incoming("999123", "2", "TEST")
self.assertFalse(sms.invalid_survey_response)
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
sms = self.assertLastOutboundSMSEquals(self.user1, "multi select 1:a, 2:b, 3:c, 4:d.")
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
sms = incoming("999123", "", "TEST")
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
sms = self.assertLastOutboundSMSEquals(self.user1, "%s multi select 1:a, 2:b, 3:c, 4:d." % get_message(MSG_FIELD_REQUIRED))
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
sms = incoming("999123", "2 x", "TEST")
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
sms = self.assertLastOutboundSMSEquals(self.user1, "%s multi select 1:a, 2:b, 3:c, 4:d." % get_message(MSG_INVALID_CHOICE))
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
sms = incoming("999123", "1 5", "TEST")
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
sms = self.assertLastOutboundSMSEquals(self.user1, "%s multi select 1:a, 2:b, 3:c, 4:d." % get_message(MSG_INVALID_CHOICE))
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
sms = incoming("999123", "1 c", "TEST")
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
sms = self.assertLastOutboundSMSEquals(self.user1, "int")
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
sms = incoming("999123", "x", "TEST")
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
sms = self.assertLastOutboundSMSEquals(self.user1, "%s int" % get_message(MSG_INVALID_INT))
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
sms = incoming("999123", "50", "TEST")
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
sms = self.assertLastOutboundSMSEquals(self.user1, "float")
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
sms = incoming("999123", "x", "TEST")
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
sms = self.assertLastOutboundSMSEquals(self.user1, "%s float" % get_message(MSG_INVALID_FLOAT))
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
sms = incoming("999123", "21.3", "TEST")
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
sms = self.assertLastOutboundSMSEquals(self.user1, "long")
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
sms = incoming("999123", "x", "TEST")
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
sms = self.assertLastOutboundSMSEquals(self.user1, "%s long" % get_message(MSG_INVALID_LONG))
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
sms = incoming("999123", "-100", "TEST")
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
sms = self.assertLastOutboundSMSEquals(self.user1, "date")
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
sms = incoming("999123", "x", "TEST")
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
sms = self.assertLastOutboundSMSEquals(self.user1, "%s date" %
get_message(MSG_INVALID_DATE, context=('YYYYMMDD',)))
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
sms = incoming("999123", "20140101", "TEST")
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
sms = self.assertLastOutboundSMSEquals(self.user1, "time")
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
sms = incoming("999123", "x", "TEST")
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
sms = self.assertLastOutboundSMSEquals(self.user1, "%s time" % get_message(MSG_INVALID_TIME))
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
sms = incoming("999123", "2500", "TEST")
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
sms = self.assertLastOutboundSMSEquals(self.user1, "%s time" % get_message(MSG_INVALID_TIME))
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
sms = incoming("999123", "2345", "TEST")
self.assertMetadataEqual(sms, session._id, WORKFLOW_KEYWORD)
form = self.get_last_form_submission()
self.assertFormQuestionEquals(form, "q_text", "abc")
self.assertFormQuestionEquals(form, "q_single_select", "b")
self.assertFormQuestionEquals(form, "q_multi_select", "a c")
self.assertFormQuestionEquals(form, "q_int", 50, cast=int)
self.assertFormQuestionEquals(form, "q_float", 21.3, cast=float)
self.assertFormQuestionEquals(form, "q_long", -100, cast=long)
self.assertFormQuestionEquals(form, "q_date", date(2014, 1, 1))
self.assertFormQuestionEquals(form, "q_time", time(23, 45), cast=time_parser)
# Mobile worker creates a case via structured sms
incoming("999123", "reg_ss pid1235 1", "TEST")
self.assertLastOutboundSMSEquals(self.user1, "Thank you for your registration submission.")
form = self.get_last_form_submission()
self.assertFormQuestionEquals(form, "participant_id", "pid1235")
self.assertFormQuestionEquals(form, "arm", "arm_a")
self.assertFormQuestionEquals(form, "external_id", "pid1235")
case = self.get_case("pid1235")
self.assertIsNotNone(case)
self.assertCasePropertyEquals(case, "name", "pid1235")
self.assertCasePropertyEquals(case, "arm", "arm_a")
# Mobile worker modifies a case
incoming("999123", "mod_ss pid1235 b", "TEST")
self.assertLastOutboundSMSEquals(self.user1, "Thank you for your modification submission.")
form = self.get_last_form_submission()
self.assertFormQuestionEquals(form, "arm", "arm_b")
case = self.get_case("pid1235")
self.assertIsNotNone(case)
self.assertCasePropertyEquals(case, "arm", "arm_b")
# Bad external id
incoming("999123", "mod_ss pid1236", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_message(MSG_CASE_NOT_FOUND))
self.assertNoNewSubmission(form)
# No external id
incoming("999123", "mod_ss", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_message(MSG_MISSING_EXTERNAL_ID))
self.assertNoNewSubmission(form)
def get_field_and_message(field_name, msg_id, additional_context=None):
msg1 = get_message(MSG_FIELD_DESCRIPTOR, context=(field_name,))
msg2 = get_message(msg_id, context=additional_context)
return "%s%s" % (msg1, msg2)
# Test validation on all fields from structured sms: positional args
incoming("999123", "validation_test_ss_1 ab 2 c 50 21.3 -100 20140101 2345", "TEST")
self.assertLastOutboundSMSEquals(self.user1, 'Expected "abc"')
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_1 abc x c 50 21.3 -100 20140101 2345", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("q_single_select", MSG_INVALID_CHOICE))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_1 abc 5 c 50 21.3 -100 20140101 2345", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("q_single_select", MSG_CHOICE_OUT_OF_RANGE))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_1 abc 2 x 50 21.3 -100 20140101 2345", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("q_multi_select", MSG_INVALID_CHOICE))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_1 abc 2 5 50 21.3 -100 20140101 2345", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("q_multi_select", MSG_INVALID_CHOICE))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_1 abc 2 c x 21.3 -100 20140101 2345", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("q_int", MSG_INVALID_INT))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_1 abc 2 c 50 x -100 20140101 2345", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("q_float", MSG_INVALID_FLOAT))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_1 abc 2 c 50 21.3 x 20140101 2345", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("q_long", MSG_INVALID_LONG))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_1 abc 2 c 50 21.3 -100 x 2345", "TEST")
self.assertLastOutboundSMSEquals(self.user1,
get_field_and_message("q_date", MSG_INVALID_DATE, ('YYYYMMDD',)))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_1 abc 2 c 50 21.3 -100 20140101 x", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("q_time", MSG_INVALID_TIME))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_1 abc 2 c 50 21.3 -100 20140101 2500", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("q_time", MSG_INVALID_TIME))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_1 abc 2 c 50 21.3 -100 20140101 2345", "TEST")
self.assertLastOutboundSMSEquals(self.user1, "Thank you for your submission.")
form = self.get_last_form_submission()
self.assertFormQuestionEquals(form, "q_text", "abc")
self.assertFormQuestionEquals(form, "q_single_select", "b")
self.assertFormQuestionEquals(form, "q_multi_select", "c")
self.assertFormQuestionEquals(form, "q_int", 50, cast=int)
self.assertFormQuestionEquals(form, "q_float", 21.3, cast=float)
self.assertFormQuestionEquals(form, "q_long", -100, cast=long)
self.assertFormQuestionEquals(form, "q_date", date(2014, 1, 1))
self.assertFormQuestionEquals(form, "q_time", time(23, 45), cast=time_parser)
# Test validation on all fields from structured sms: positional args with custom delimiter
incoming("999123", "validation_test_ss_2,ab,2,1 c,50,21.3,-100,20140101,2345", "TEST")
self.assertLastOutboundSMSEquals(self.user1, 'Expected "abc"')
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_2,abc,x,1 c,50,21.3,-100,20140101,2345", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("q_single_select", MSG_INVALID_CHOICE))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_2,abc,5,1 c,50,21.3,-100,20140101,2345", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("q_single_select", MSG_CHOICE_OUT_OF_RANGE))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_2,abc,2,1 x,50,21.3,-100,20140101,2345", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("q_multi_select", MSG_INVALID_CHOICE))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_2,abc,2,1 5,50,21.3,-100,20140101,2345", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("q_multi_select", MSG_INVALID_CHOICE))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_2,abc,2,,50,21.3,-100,20140101,2345", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("q_multi_select", MSG_FIELD_REQUIRED))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_2,abc,2,1 c,x,21.3,-100,20140101,2345", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("q_int", MSG_INVALID_INT))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_2,abc,2,1 c,50,x,-100,20140101,2345", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("q_float", MSG_INVALID_FLOAT))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_2,abc,2,1 c,50,21.3,x,20140101,2345", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("q_long", MSG_INVALID_LONG))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_2,abc,2,1 c,50,21.3,-100,x,2345", "TEST")
self.assertLastOutboundSMSEquals(self.user1,
get_field_and_message("q_date", MSG_INVALID_DATE, ('YYYYMMDD',)))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_2,abc,2,1 c,50,21.3,-100,20140101,x", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("q_time", MSG_INVALID_TIME))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_2,abc,2,1 c,50,21.3,-100,20140101,2500", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("q_time", MSG_INVALID_TIME))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_2,abc,2,1 c,50,21.3,-100,20140101,2345", "TEST")
self.assertLastOutboundSMSEquals(self.user1, "Thank you for your submission.")
form = self.get_last_form_submission()
self.assertFormQuestionEquals(form, "q_text", "abc")
self.assertFormQuestionEquals(form, "q_single_select", "b")
self.assertFormQuestionEquals(form, "q_multi_select", "a c")
self.assertFormQuestionEquals(form, "q_int", 50, cast=int)
self.assertFormQuestionEquals(form, "q_float", 21.3, cast=float)
self.assertFormQuestionEquals(form, "q_long", -100, cast=long)
self.assertFormQuestionEquals(form, "q_date", date(2014, 1, 1))
self.assertFormQuestionEquals(form, "q_time", time(23, 45), cast=time_parser)
# Test validation on all fields from structured sms: named args with custom delimiter
incoming("999123", "validation_test_ss_3,arg1ab,arg22,arg31 c,arg450,arg521.3,arg6-100,arg720140101,arg82345", "TEST")
self.assertLastOutboundSMSEquals(self.user1, 'Expected "abc"')
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_3,arg1abc,arg2x,arg31 c,arg450,arg521.3,arg6-100,arg720140101,arg82345", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("ARG2", MSG_INVALID_CHOICE))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_3,arg1abc,arg25,arg31 c,arg450,arg521.3,arg6-100,arg720140101,arg82345", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("ARG2", MSG_CHOICE_OUT_OF_RANGE))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_3,arg1abc,arg22,arg31 x,arg450,arg521.3,arg6-100,arg720140101,arg82345", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("ARG3", MSG_INVALID_CHOICE))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_3,arg1abc,arg22,arg31 5,arg450,arg521.3,arg6-100,arg720140101,arg82345", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("ARG3", MSG_INVALID_CHOICE))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_3,arg1abc,arg22,arg3,arg450,arg521.3,arg6-100,arg720140101,arg82345", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("ARG3", MSG_FIELD_REQUIRED))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_3,arg1abc,arg22,arg31 c,arg4x,arg521.3,arg6-100,arg720140101,arg82345", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("ARG4", MSG_INVALID_INT))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_3,arg1abc,arg22,arg31 c,arg450,arg5x,arg6-100,arg720140101,arg82345", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("ARG5", MSG_INVALID_FLOAT))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_3,arg1abc,arg22,arg31 c,arg450,arg521.3,arg6x,arg720140101,arg82345", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("ARG6", MSG_INVALID_LONG))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_3,arg1abc,arg22,arg31 c,arg450,arg521.3,arg6-100,arg7x,arg82345", "TEST")
self.assertLastOutboundSMSEquals(self.user1,
get_field_and_message("ARG7", MSG_INVALID_DATE, ('YYYYMMDD',)))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_3,arg1abc,arg22,arg31 c,arg450,arg521.3,arg6-100,arg720140101,arg8x", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("ARG8", MSG_INVALID_TIME))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_3,arg1abc,arg22,arg31 c,arg450,arg521.3,arg6-100,arg720140101,arg82500", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("ARG8", MSG_INVALID_TIME))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_3,arg1abc,arg22,arg31 c,arg450,arg521.3,arg6-100,arg720140101,arg82345", "TEST")
self.assertLastOutboundSMSEquals(self.user1, "Thank you for your submission.")
form = self.get_last_form_submission()
self.assertFormQuestionEquals(form, "q_text", "abc")
self.assertFormQuestionEquals(form, "q_single_select", "b")
self.assertFormQuestionEquals(form, "q_multi_select", "a c")
self.assertFormQuestionEquals(form, "q_int", 50, cast=int)
self.assertFormQuestionEquals(form, "q_float", 21.3, cast=float)
self.assertFormQuestionEquals(form, "q_long", -100, cast=long)
self.assertFormQuestionEquals(form, "q_date", date(2014, 1, 1))
self.assertFormQuestionEquals(form, "q_time", time(23, 45), cast=time_parser)
# Test validation on all fields from structured sms: named args with custom delimiter and joining character
incoming("999123", "validation_test_ss_4,arg1=ab,arg2=2,arg3=1 c,arg4=50,arg5=21.3,arg6=-100,arg7=20140101,arg8=2345", "TEST")
self.assertLastOutboundSMSEquals(self.user1, 'Expected "abc"')
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_4,arg1=abc,arg2=x,arg3=1 c,arg4=50,arg5=21.3,arg6=-100,arg7=20140101,arg8=2345", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("ARG2", MSG_INVALID_CHOICE))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_4,arg1=abc,arg2=5,arg3=1 c,arg4=50,arg5=21.3,arg6=-100,arg7=20140101,arg8=2345", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("ARG2", MSG_CHOICE_OUT_OF_RANGE))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_4,arg1=abc,arg2=2,arg3=1 x,arg4=50,arg5=21.3,arg6=-100,arg7=20140101,arg8=2345", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("ARG3", MSG_INVALID_CHOICE))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_4,arg1=abc,arg2=2,arg3=1 5,arg4=50,arg5=21.3,arg6=-100,arg7=20140101,arg8=2345", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("ARG3", MSG_INVALID_CHOICE))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_4,arg1=abc,arg2=2,arg3=,arg4=50,arg5=21.3,arg6=-100,arg7=20140101,arg8=2345", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("ARG3", MSG_FIELD_REQUIRED))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_4,arg1=abc,arg2=2,arg3=1 c,arg4=x,arg5=21.3,arg6=-100,arg7=20140101,arg8=2345", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("ARG4", MSG_INVALID_INT))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_4,arg1=abc,arg2=2,arg3=1 c,arg4=50,arg5=x,arg6=-100,arg7=20140101,arg8=2345", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("ARG5", MSG_INVALID_FLOAT))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_4,arg1=abc,arg2=2,arg3=1 c,arg4=50,arg5=21.3,arg6=x,arg7=20140101,arg8=2345", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("ARG6", MSG_INVALID_LONG))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_4,arg1=abc,arg2=2,arg3=1 c,arg4=50,arg5=21.3,arg6=-100,arg7=x,arg8=2345", "TEST")
self.assertLastOutboundSMSEquals(self.user1,
get_field_and_message("ARG7", MSG_INVALID_DATE, ('YYYYMMDD',)))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_4,arg1=abc,arg2=2,arg3=1 c,arg4=50,arg5=21.3,arg6=-100,arg7=20140101,arg8=x", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("ARG8", MSG_INVALID_TIME))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_4,arg1=abc,arg2=2,arg3=1 c,arg4=50,arg5=21.3,arg6=-100,arg7=20140101,arg8=2500", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("ARG8", MSG_INVALID_TIME))
self.assertNoNewSubmission(form)
incoming("999123", "validation_test_ss_4,arg1=abc,arg2=2,arg3=1 c,arg4=50,arg5=21.3,arg6=-100,arg7=20140101,arg8=2345", "TEST")
self.assertLastOutboundSMSEquals(self.user1, "Thank you for your submission.")
form = self.get_last_form_submission()
self.assertFormQuestionEquals(form, "q_text", "abc")
self.assertFormQuestionEquals(form, "q_single_select", "b")
self.assertFormQuestionEquals(form, "q_multi_select", "a c")
self.assertFormQuestionEquals(form, "q_int", 50, cast=int)
self.assertFormQuestionEquals(form, "q_float", 21.3, cast=float)
self.assertFormQuestionEquals(form, "q_long", -100, cast=long)
self.assertFormQuestionEquals(form, "q_date", date(2014, 1, 1))
self.assertFormQuestionEquals(form, "q_time", time(23, 45), cast=time_parser)
# Test leaving fields blank via structured sms
incoming("999123", "validation_test_ss_4,arg1=abc,arg3=1 c", "TEST")
self.assertLastOutboundSMSEquals(self.user1, "Thank you for your submission.")
form = self.get_last_form_submission()
self.assertFormQuestionEquals(form, "q_text", "abc")
self.assertFormQuestionEquals(form, "q_single_select", "")
self.assertFormQuestionEquals(form, "q_multi_select", "a c")
self.assertFormQuestionEquals(form, "q_int", "")
self.assertFormQuestionEquals(form, "q_float", "")
self.assertFormQuestionEquals(form, "q_long", "")
self.assertFormQuestionEquals(form, "q_date", "")
self.assertFormQuestionEquals(form, "q_time", "")
incoming("999123", "validation_test_ss_1 abc b c", "TEST")
self.assertLastOutboundSMSEquals(self.user1, "Thank you for your submission.")
form = self.get_last_form_submission()
self.assertFormQuestionEquals(form, "q_text", "abc")
self.assertFormQuestionEquals(form, "q_single_select", "b")
self.assertFormQuestionEquals(form, "q_multi_select", "c")
self.assertFormQuestionEquals(form, "q_int", "")
self.assertFormQuestionEquals(form, "q_float", "")
self.assertFormQuestionEquals(form, "q_long", "")
self.assertFormQuestionEquals(form, "q_date", "")
self.assertFormQuestionEquals(form, "q_time", "")
incoming("999123", "mod_ss_2,pid1235", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("arm", MSG_FIELD_REQUIRED))
self.assertNoNewSubmission(form)
incoming("999123", "mod_ss_2,pid1235,", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("arm", MSG_FIELD_REQUIRED))
self.assertNoNewSubmission(form)
incoming("999123", "mod_ss_3,pid1235,arm=", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_field_and_message("ARM", MSG_FIELD_REQUIRED))
self.assertNoNewSubmission(form)
incoming("999123", "mod_ss_3,pid1235,arm a", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_message(MSG_EXPECTED_NAMED_ARGS_SEPARATOR, context=("=",)))
self.assertNoNewSubmission(form)
incoming("999123", "mod_ss_3,pid1235,arm=a,arm=b", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_message(MSG_MULTIPLE_ANSWERS_FOUND, context=("ARM",)))
self.assertNoNewSubmission(form)
incoming("999123", "mod_ss_3 , pid1235 , arm = a", "TEST")
self.assertLastOutboundSMSEquals(self.user1, "Thank you for your modification submission.")
form = self.get_last_form_submission()
self.assertFormQuestionEquals(form, "arm", "arm_a")
case = self.get_case("pid1235")
self.assertIsNotNone(case)
self.assertCasePropertyEquals(case, "arm", "arm_a")
# Test global keywords
incoming("999123", "#start unknownkeyword", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_message(MSG_KEYWORD_NOT_FOUND, context=("UNKNOWNKEYWORD",)))
self.assertNoNewSubmission(form)
incoming("999123", "#start", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_message(MSG_START_KEYWORD_USAGE, context=("#START",)))
self.assertNoNewSubmission(form)
incoming("999123", "#unknown", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_message(MSG_UNKNOWN_GLOBAL_KEYWORD, context=("#UNKNOWN",)))
self.assertNoNewSubmission(form)
# Mobile worker creates a case
incoming("999123", "#start reg", "TEST")
self.assertLastOutboundSMSEquals(self.user1, "Enter Participant ID")
incoming("999123", "pid1237", "TEST")
self.assertLastOutboundSMSEquals(self.user1, "Enter Study Arm 1:a, 2:b.")
incoming("999123", "1", "TEST")
form = self.get_last_form_submission()
self.assertFormQuestionEquals(form, "participant_id", "pid1237")
self.assertFormQuestionEquals(form, "arm", "arm_a")
self.assertFormQuestionEquals(form, "external_id", "pid1237")
case = self.get_case("pid1237")
self.assertIsNotNone(case)
self.assertCasePropertyEquals(case, "name", "pid1237")
self.assertCasePropertyEquals(case, "arm", "arm_a")
# Mobile worker modifies a case
incoming("999123", "#start mod pid1237", "TEST")
self.assertLastOutboundSMSEquals(self.user1, "Enter Study Arm 1:a, 2:b.")
incoming("999123", "b", "TEST")
form = self.get_last_form_submission()
self.assertFormQuestionEquals(form, "arm", "arm_b")
case = self.get_case("pid1237")
self.assertIsNotNone(case)
self.assertCasePropertyEquals(case, "arm", "arm_b")
# Bad external id
incoming("999123", "#start mod pid1240", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_message(MSG_CASE_NOT_FOUND))
self.assertNoNewSubmission(form)
# No external id
incoming("999123", "#start mod", "TEST")
self.assertLastOutboundSMSEquals(self.user1, get_message(MSG_MISSING_EXTERNAL_ID))
self.assertNoNewSubmission(form)
# CURRENT keyword
incoming("999123", "reg", "TEST")
sms1 = self.assertLastOutboundSMSEquals(self.user1, "Enter Participant ID")
incoming("999123", "#CURRENT", "TEST")
sms2 = self.assertLastOutboundSMSEquals(self.user1, "Enter Participant ID")
self.assertNotEqual(sms1.pk, sms2.pk)
# STOP keyword
session = self.get_open_session(self.user1)
self.assertIsNotNone(session)
incoming("999123", "#STOP", "TEST")
session = self.get_open_session(self.user1)
self.assertIsNone(session)
self.assertNoNewSubmission(form)
# One keyword overrides another
incoming("999123", "reg", "TEST")
sms1 = self.assertLastOutboundSMSEquals(self.user1, "Enter Participant ID")
incoming("999123", "mod pid1237", "TEST")
self.assertLastOutboundSMSEquals(self.user1, "Enter Study Arm 1:a, 2:b.")
self.assertNoNewSubmission(form)
incoming("999123", "reg", "TEST")
self.assertLastOutboundSMSEquals(self.user1, "%s Enter Study Arm 1:a, 2:b." % get_message(MSG_INVALID_CHOICE))
incoming("999123", "a", "TEST")
form = self.get_last_form_submission()
self.assertFormQuestionEquals(form, "arm", "arm_a")
case = self.get_case("pid1237")
self.assertIsNotNone(case)
self.assertCasePropertyEquals(case, "arm", "arm_a")
# Test initator filters
case = self.get_case("pid1237")
update_case(self.domain, case.case_id,
case_properties={'contact_phone_number': '999124', 'contact_phone_number_is_verified': '1'})
case = CaseAccessors(self.domain).get_case(case.case_id)
incoming("999123", "for_user", "TEST")
self.assertLastOutboundSMSEquals(self.user1, "This message is for users")
incoming("999123", "for_case", "TEST")
self.assertLastOutboundSMSEquals(self.user1, "Default SMS Response")
incoming("999124", "for_case", "TEST")
self.assertLastOutboundSMSEquals(case, "This message is for cases")
incoming("999124", "for_user", "TEST")
self.assertLastOutboundSMSEquals(case, "Default SMS Response")
# Test form over sms for case
incoming("999124", "mod", "TEST")
self.assertLastOutboundSMSEquals(case, "Enter Study Arm 1:a, 2:b.")
incoming("999123", "mod pid1237", "TEST")
self.assertLastOutboundSMSEquals(self.user1, "Enter Study Arm 1:a, 2:b.")
incoming("999124", "b", "TEST")
form = self.get_last_form_submission()
self.assertFormQuestionEquals(form, "arm", "arm_b")
case = self.get_case("pid1237")
self.assertCasePropertyEquals(case, "arm", "arm_b")
incoming("999123", "a", "TEST")
form = self.get_last_form_submission()
self.assertFormQuestionEquals(form, "arm", "arm_a")
case = self.get_case("pid1237")
self.assertCasePropertyEquals(case, "arm", "arm_a")
# Test structured sms for case
incoming("999124", "mod_ss 2", "TEST")
self.assertLastOutboundSMSEquals(case, "Thank you for your modification submission.")
form = self.get_last_form_submission()
self.assertFormQuestionEquals(form, "arm", "arm_b")
case = self.get_case("pid1237")
self.assertCasePropertyEquals(case, "arm", "arm_b")
# Test Auth
incoming("999122", "mod pid1237", "TEST")
self.assertLastOutboundSMSEquals(self.user2, get_message(MSG_CASE_NOT_FOUND))
# Test notifying others
incoming("999124", "for_owner", "TEST")
self.assertLastOutboundSMSEquals(self.user1, "This message is for the case owner")
incoming("999124", "for_group", "TEST")
self.assertLastOutboundSMSEquals(self.user1, "This message is for the group")
self.assertLastOutboundSMSEquals(self.user2, "This message is for the group")
case = self.get_case("pid1237")
self.update_case_owner(case, self.group1)
incoming("999124", "for_owner", "TEST")
self.assertLastOutboundSMSEquals(self.user1, "This message is for the case owner")
self.assertLastOutboundSMSEquals(self.user2, "This message is for the case owner")
# Test case sharing auth
incoming("999122", "mod pid1237", "TEST")
self.assertLastOutboundSMSEquals(self.user2, "Enter Study Arm 1:a, 2:b.")
incoming("999122", "1", "TEST")
form = self.get_last_form_submission()
self.assertFormQuestionEquals(form, "arm", "arm_a")
case = self.get_case("pid1237")
self.assertCasePropertyEquals(case, "arm", "arm_a")
# Test closing open sessions on an sms reply
incoming("999122", "reg", "TEST")
self.assertLastOutboundSMSEquals(self.user2, "Enter Participant ID")
incoming("999122", "for_user", "TEST")
self.assertLastOutboundSMSEquals(self.user2, "This message is for users")
incoming("999122", "null", "TEST")
self.assertLastOutboundSMSEquals(self.user2, "Default SMS Response")
def test_case_property_start_date_with_blank_option(self):
reminder = (CaseReminderHandler
.create(self.domain, 'test')
.set_case_criteria_start_condition('participant', 'status', MATCH_EXACT, 'green')
.set_case_criteria_start_date(start_date='start_date')
.set_case_recipient()
.set_sms_content_type('en')
.set_daily_schedule(fire_time=time(12, 0),
message={'en': 'Hello {case.name}, your test result was normal.'})
.set_stop_condition(max_iteration_count=30)
.set_advanced_options(use_today_if_start_date_is_blank=True))
reminder.save()
self.assertEqual(self.get_reminders(), [])
with create_test_case(self.domain, 'participant', 'bob', drop_signals=False) as case, \
patch('corehq.apps.reminders.models.CaseReminderHandler.get_now') as now_mock:
self.assertEqual(self.get_reminders(), [])
now_mock.return_value = datetime(2016, 1, 1, 10, 0)
# start_date is blank, but reminder should be spawned using today's value
update_case(self.domain, case.case_id, case_properties={'status': 'green'})
reminder_instance = self.assertOneReminder()
self.assertEqual(reminder_instance.domain, self.domain)
self.assertEqual(reminder_instance.case_id, case.case_id)
self.assertEqual(reminder_instance.handler_id, reminder.get_id)
self.assertIsNone(reminder_instance.user_id)
self.assertEqual(reminder_instance.next_fire, datetime(2016, 1, 1, 12, 0))
self.assertTrue(reminder_instance.active)
self.assertEqual(reminder_instance.start_date, date(2016, 1, 1))
self.assertEqual(reminder_instance.schedule_iteration_num, 1)
self.assertEqual(reminder_instance.current_event_sequence_num, 0)
self.assertEqual(reminder_instance.callback_try_count, 0)
self.assertIsNone(reminder_instance.start_condition_datetime)
self.assertEqual(reminder_instance.callback_try_count, 0)
# update start_date and the schedule should be recalculated
update_case(self.domain, case.case_id, case_properties={'start_date': '2016-01-08'})
reminder_instance = self.assertOneReminder()
self.assertEqual(reminder_instance.domain, self.domain)
self.assertEqual(reminder_instance.case_id, case.case_id)
self.assertEqual(reminder_instance.handler_id, reminder.get_id)
self.assertIsNone(reminder_instance.user_id)
self.assertEqual(reminder_instance.next_fire, datetime(2016, 1, 8, 12, 0))
self.assertTrue(reminder_instance.active)
self.assertEqual(reminder_instance.start_date, date(2016, 1, 8))
self.assertEqual(reminder_instance.schedule_iteration_num, 1)
self.assertEqual(reminder_instance.current_event_sequence_num, 0)
self.assertEqual(reminder_instance.callback_try_count, 0)
self.assertEqual(reminder_instance.start_condition_datetime, datetime(2016, 1, 8))
self.assertEqual(reminder_instance.callback_try_count, 0)
# update start_date to be in the past and the schedule should be recalculated and fast-forwarded
update_case(self.domain, case.case_id, case_properties={'start_date': '2015-12-20'})
reminder_instance = self.assertOneReminder()
self.assertEqual(reminder_instance.domain, self.domain)
self.assertEqual(reminder_instance.case_id, case.case_id)
self.assertEqual(reminder_instance.handler_id, reminder.get_id)
self.assertIsNone(reminder_instance.user_id)
self.assertEqual(reminder_instance.next_fire, datetime(2016, 1, 1, 12, 0))
self.assertTrue(reminder_instance.active)
self.assertEqual(reminder_instance.start_date, date(2015, 12, 20))
self.assertEqual(reminder_instance.schedule_iteration_num, 13)
self.assertEqual(reminder_instance.current_event_sequence_num, 0)
self.assertEqual(reminder_instance.callback_try_count, 0)
self.assertEqual(reminder_instance.start_condition_datetime, datetime(2015, 12, 20))
self.assertEqual(reminder_instance.callback_try_count, 0)
# update start_date to be further in the past and the reminder should be deactivated
update_case(self.domain, case.case_id, case_properties={'start_date': '2015-12-01'})
reminder_instance = self.assertOneReminder()
self.assertEqual(reminder_instance.domain, self.domain)
self.assertEqual(reminder_instance.case_id, case.case_id)
self.assertEqual(reminder_instance.handler_id, reminder.get_id)
self.assertIsNone(reminder_instance.user_id)
self.assertEqual(reminder_instance.next_fire, datetime(2015, 12, 31, 12, 0))
self.assertFalse(reminder_instance.active)
self.assertEqual(reminder_instance.start_date, date(2015, 12, 1))
self.assertEqual(reminder_instance.schedule_iteration_num, 31)
self.assertEqual(reminder_instance.current_event_sequence_num, 0)
self.assertEqual(reminder_instance.callback_try_count, 0)
self.assertEqual(reminder_instance.start_condition_datetime, datetime(2015, 12, 1))
self.assertEqual(reminder_instance.callback_try_count, 0)
# set start_date to be blank and the reminder should go back to using today as start date
update_case(self.domain, case.case_id, case_properties={'start_date': ''})
reminder_instance = self.assertOneReminder()
self.assertEqual(reminder_instance.domain, self.domain)
self.assertEqual(reminder_instance.case_id, case.case_id)
self.assertEqual(reminder_instance.handler_id, reminder.get_id)
self.assertIsNone(reminder_instance.user_id)
self.assertEqual(reminder_instance.next_fire, datetime(2016, 1, 1, 12, 0))
self.assertTrue(reminder_instance.active)
self.assertEqual(reminder_instance.start_date, date(2016, 1, 1))
self.assertEqual(reminder_instance.schedule_iteration_num, 1)
self.assertEqual(reminder_instance.current_event_sequence_num, 0)
self.assertEqual(reminder_instance.callback_try_count, 0)
self.assertIsNone(reminder_instance.start_condition_datetime)
self.assertEqual(reminder_instance.callback_try_count, 0)
def update_single_case(self, episode_case):
# updates a single episode_case.
assert episode_case.domain == self.domain
update_json = EpisodeAdherenceUpdate(episode_case, self).update_json()
if update_json:
update_case(self.domain, episode_case.case_id, update_json)
def test_static_negative_growth_indicator(self):
c = CustomContent(custom_content_id='ICDS_STATIC_NEGATIVE_GROWTH_MESSAGE')
schedule_instance = CaseTimedScheduleInstance(
domain=self.domain,
case_id=self.child_health_case.case_id,
)
c.set_context(schedule_instance=schedule_instance)
# Test when current weight is greater than previous
submit_growth_form(self.domain, self.child_health_case.case_id, '10.1', '10.4')
self.assertEqual(
c.get_list_of_messages(self.mother_person_case),
[]
)
# Test when current weight is equal to previous
submit_growth_form(self.domain, self.child_health_case.case_id, '10.1', '10.1')
self.assertEqual(
c.get_list_of_messages(self.mother_person_case),
["As per the latest records of your AWC, the weight of your child Joe has remained static in the last "
"month. Please consult your AWW for necessary advice."]
)
# Test when current weight is less than previous
submit_growth_form(self.domain, self.child_health_case.case_id, '10.1', '9.9')
self.assertEqual(
c.get_list_of_messages(self.mother_person_case),
["As per the latest records of your AWC, the weight of your child Joe has reduced in the last month. "
"Please consult your AWW for necessary advice."]
)
# Test ignoring forms with the wrong xmlns
update_case(self.domain, self.child_health_case.case_id, {'property': 'value1'})
update_case(self.domain, self.child_health_case.case_id, {'property': 'value2'})
update_case(self.domain, self.child_health_case.case_id, {'property': 'value3'})
update_case(self.domain, self.child_health_case.case_id, {'property': 'value4'})
update_case(self.domain, self.child_health_case.case_id, {'property': 'value5'})
update_case(self.domain, self.child_health_case.case_id, {'property': 'value6'})
update_case(self.domain, self.child_health_case.case_id, {'property': 'value7'})
update_case(self.domain, self.child_health_case.case_id, {'property': 'value8'})
update_case(self.domain, self.child_health_case.case_id, {'property': 'value9'})
update_case(self.domain, self.child_health_case.case_id, {'property': 'value10'})
self.assertEqual(
c.get_list_of_messages(self.mother_person_case),
["As per the latest records of your AWC, the weight of your child Joe has reduced in the last month. "
"Please consult your AWW for necessary advice."]
)