def handle(self, *args, **options):
ids = self.get_reminder_definition_ids()
for handler_doc in iter_docs(CaseReminderHandler.get_db(), ids):
handler = CaseReminderHandler.wrap(handler_doc)
if handler.reminder_type == REMINDER_TYPE_DEFAULT:
self.check_for_ui_type(handler)
self.check_for_multiple_fire_time_types(handler)
self.check_for_datetime_criteria(handler)
self.check_for_case_group_recipient(handler)
def fire_ivr_survey_event(reminder, handler, recipients, verified_numbers, logged_event):
domain_obj = Domain.get_by_name(reminder.domain, strict=True)
for recipient in recipients:
initiate_call = True
if reminder.callback_try_count > 0 and reminder.event_initiation_timestamp:
initiate_call = not Call.answered_call_exists(
recipient.doc_type,
recipient.get_id,
reminder.event_initiation_timestamp
)
if initiate_call:
if (is_commcarecase(recipient) and
not handler.force_surveys_to_use_triggered_case):
case_id = recipient.case_id
else:
case_id = reminder.case_id
verified_number, unverified_number = get_recipient_phone_number(
reminder, recipient, verified_numbers)
if verified_number:
initiate_outbound_call.delay(
recipient,
reminder.current_event.form_unique_id,
handler.submit_partial_forms,
handler.include_case_side_effects,
handler.max_question_retries,
logged_event.pk,
verified_number=verified_number,
case_id=case_id,
case_for_case_submission=handler.force_surveys_to_use_triggered_case,
timestamp=CaseReminderHandler.get_now(),
)
elif domain_obj.send_to_duplicated_case_numbers and unverified_number:
initiate_outbound_call.delay(
recipient,
reminder.current_event.form_unique_id,
handler.submit_partial_forms,
handler.include_case_side_effects,
handler.max_question_retries,
logged_event.pk,
unverified_number=unverified_number,
case_id=case_id,
case_for_case_submission=handler.force_surveys_to_use_triggered_case,
timestamp=CaseReminderHandler.get_now(),
)
else:
# initiate_outbound_call will create the subevent automatically,
# so since we're not initiating the call here, we have to create
# the subevent explicitly in order to log the error.
logged_subevent = logged_event.create_subevent(handler, reminder, recipient)
logged_subevent.error(MessagingEvent.ERROR_NO_PHONE_NUMBER)
def get_broadcast_ajax_response(self, upcoming=True):
"""
upcoming - True to include only upcoming broadcasts, False to include
only past broadcasts.
"""
if upcoming:
ids = CaseReminderHandler.get_upcoming_broadcast_ids(self.domain)
else:
ids = CaseReminderHandler.get_past_broadcast_ids(self.domain)
total_records = len(ids)
ids = ids[self.display_start:self.display_start + self.display_length]
data = self.format_broadcast_data(ids)
return self.datatables_ajax_response(data, total_records)
def _active_reminders(self):
db = CaseReminderHandler.get_db()
key = [self.domain.name]
reminder_rules = db.view(
'reminders/handlers_by_reminder_type',
startkey=key,
endkey=key+[{}],
reduce=False
).all()
active_reminders = []
for reminder_doc in iter_docs(db, [r['id'] for r in reminder_rules]):
if reminder_doc.get('active', True):
active_reminders.append(CaseReminderHandler.wrap(reminder_doc))
return active_reminders
def rule_progress(request, domain):
client = get_redis_client()
handlers = CaseReminderHandler.get_handlers(domain,
reminder_type_filter=REMINDER_TYPE_DEFAULT)
response = {}
for handler in handlers:
info = {}
if handler.locked:
info['complete'] = False
current = None
total = None
try:
current = client.get('reminder-rule-processing-current-%s' % handler._id)
total = client.get('reminder-rule-processing-total-%s' % handler._id)
except:
continue
info['current'] = int_or_none(current)
info['total'] = int_or_none(total)
else:
info['complete'] = True
response[handler._id] = info
return HttpResponse(json.dumps(response))
def clean(self):
cleaned_data = self.cleaned_data
sm = cleaned_data["share_multimedia"]
license = cleaned_data["license"]
app_ids = self._get_apps_to_publish()
if sm and license not in self.dom.most_restrictive_licenses(apps_to_check=app_ids):
license_choices = [LICENSES[l] for l in self.dom.most_restrictive_licenses(apps_to_check=app_ids)]
msg = render_to_string('domain/partials/restrictive_license.html', {'licenses': license_choices})
self._errors["license"] = self.error_class([msg])
del cleaned_data["license"]
sr = cleaned_data["share_reminders"]
if sr: # check that the forms referenced by the events in each reminders exist in the project
referenced_forms = CaseReminderHandler.get_referenced_forms(domain=self.dom.name)
if referenced_forms:
apps = [Application.get(app_id) for app_id in app_ids]
app_forms = [f.unique_id for forms in [app.get_forms() for app in apps] for f in forms]
nonexistent_forms = filter(lambda f: f not in app_forms, referenced_forms)
nonexistent_forms = [FormBase.get_form(f) for f in nonexistent_forms]
if nonexistent_forms:
msg = """
Your reminders reference forms that are not being published.
Make sure the following forms are being published: %s
""" % str([f.default_name() for f in nonexistent_forms]).strip('[]')
self._errors["share_reminders"] = self.error_class([msg])
return cleaned_data
def get_active_reminders_by_domain_name(domain_name):
from corehq.apps.reminders.models import CaseReminderHandler, REMINDER_TYPE_DEFAULT, REMINDER_TYPE_KEYWORD_INITIATED
db = CaseReminderHandler.get_db()
key = [domain_name]
reminder_rules = db.view(
"reminders/handlers_by_reminder_type", startkey=key, endkey=(key + [{}]), reduce=False
).all()
return [
CaseReminderHandler.wrap(reminder_doc)
for reminder_doc in iter_docs(db, [r["id"] for r in reminder_rules])
if (
reminder_doc.get("active", True)
and reminder_doc.get("reminder_type", REMINDER_TYPE_DEFAULT) != REMINDER_TYPE_KEYWORD_INITIATED
)
]
def setUp(self):
super(ReminderTestCase, self).setUp()
self.domain = self.domain_obj.name
self.case_type = "my_case_type"
self.message = "Test reminder message."
self.handler = (CaseReminderHandler.create(self.domain, 'test')
.set_case_criteria_start_condition(self.case_type, 'start_sending', MATCH_EXACT, 'ok')
.set_case_criteria_start_date(start_offset=1)
.set_last_submitting_user_recipient()
.set_sms_content_type('en')
.set_schedule_manually(
EVENT_AS_OFFSET,
3,
[
CaseReminderEvent(
day_num=0,
fire_time=time(0, 0),
message={'en': self.message},
callback_timeout_intervals=[]
),
])
.set_stop_condition(stop_case_property='stop_sending')
.set_advanced_options()
)
self.handler.save()
self.user = CommCareUser.create(self.domain, 'chw.bob', 'abc', phone_number='99912345')
def setUp(self):
super(StartConditionReminderTestCase, self).setUp()
self.domain = self.domain_obj.name
self.user = CommCareUser.create(self.domain, 'chw.bob5', 'abc', phone_number='99912345')
self.handler1 = (CaseReminderHandler.create(self.domain, 'test')
.set_case_criteria_start_condition('case_type_a', 'start_sending1',
MATCH_REGEX, '^(ok|\d\d\d\d-\d\d-\d\d)')
.set_case_criteria_start_date(start_date='start_sending1', start_offset=1)
.set_last_submitting_user_recipient()
.set_sms_content_type('en')
.set_schedule_manually(
EVENT_AS_OFFSET,
3,
[
CaseReminderEvent(
day_num=0,
fire_time=time(0, 0),
message={'en': 'Message1'},
callback_timeout_intervals=[]
),
])
.set_stop_condition(stop_case_property='stop_sending1')
.set_advanced_options(use_today_if_start_date_is_blank=True))
self.handler1.save()
def scheduled_reminders(request, domain, template="reminders/partial/scheduled_reminders.html"):
reminders = CaseReminderHandler.get_all_reminders(domain)
dates = []
now = datetime.utcnow()
today = now.date()
if reminders:
start_date = reminders[0].next_fire.date()
if today < start_date:
start_date = today
end_date = reminders[-1].next_fire.date()
else:
start_date = end_date = today
# make sure start date is a Monday and enddate is a Sunday
start_date -= timedelta(days=start_date.weekday())
end_date += timedelta(days=6-end_date.weekday())
while start_date <= end_date:
dates.append(start_date)
start_date += timedelta(days=1)
return render_to_response(request, template, {
'domain': domain,
'reminders': reminders,
'dates': dates,
'today': today,
'now': now,
})
def case_changed(self, domain, case_id):
try:
handler_ids = CaseReminderHandler.get_handler_ids(domain, reminder_type_filter=REMINDER_TYPE_DEFAULT)
if handler_ids:
_case_changed(case_id, handler_ids)
except Exception as e:
self.retry(exc=e)
def list_reminders(request, domain, template="reminders/partial/list_reminders.html"):
handlers = CaseReminderHandler.get_handlers(domain=domain).all()
print handlers
return render_to_response(request, template, {
'domain': domain,
'reminder_handlers': handlers
})
def add_reminder(request, domain, handler_id=None, template="reminders/partial/add_reminder.html"):
if handler_id:
handler = CaseReminderHandler.get(handler_id)
if handler.doc_type != 'CaseReminderHandler' or handler.domain != domain:
raise Http404
else:
handler = None
if request.method == "POST":
reminder_form = CaseReminderForm(request.POST)
if reminder_form.is_valid():
if not handler:
handler = CaseReminderHandler(domain=domain)
handler.ui_type = UI_SIMPLE_FIXED
for key, value in reminder_form.cleaned_data.items():
if (key != "frequency") and (key != "message"):
handler[key] = value
handler.max_iteration_count = REPEAT_SCHEDULE_INDEFINITELY
handler.schedule_length = reminder_form.cleaned_data["frequency"]
handler.event_interpretation = EVENT_AS_OFFSET
handler.events = [
CaseReminderEvent(
day_num = 0
,fire_time = time(hour=0,minute=0,second=0)
,message = reminder_form.cleaned_data["message"]
,callback_timeout_intervals = []
)
]
handler.save()
print handler.events[0].message
return HttpResponseRedirect(reverse('list_reminders', args=[domain]))
elif handler:
initial = {}
for key in handler.to_json():
if (key != "max_iteration_count") and (key != "schedule_length") and (key != "events") and (key != "event_interpretation"):
initial[key] = handler[key]
initial["message"] = json.dumps(handler.events[0].message)
initial["frequency"] = handler.schedule_length
reminder_form = CaseReminderForm(initial=initial)
else:
reminder_form = CaseReminderForm()
return render_to_response(request, template, {
'reminder_form': reminder_form,
'domain': domain
})
def domain_has_active_reminders(self, domain):
for handler in CaseReminderHandler.get_handlers(
domain.name,
reminder_type_filter=REMINDER_TYPE_DEFAULT
):
if handler.active:
return True
return False
def reminder_handler(self):
try:
handler = CaseReminderHandler.get(self.handler_id)
assert handler.domain == self.domain
assert handler.doc_type == "CaseReminderHandler"
return handler
except (ResourceNotFound, AssertionError):
raise Http404()
def page_context(self):
page_context = super(ScheduledRemindersCalendarView, self).page_context
timezone = Domain.get_by_name(self.domain).get_default_timezone()
reminders = CaseReminderHandler.get_all_reminders(self.domain)
dates = []
now = datetime.utcnow()
timezone_now = datetime.now(timezone)
today = timezone_now.date()
def adjust_next_fire_to_timezone(reminder_utc):
return ServerTime(reminder_utc.next_fire).user_time(timezone).done()
if reminders:
start_date = adjust_next_fire_to_timezone(reminders[0]).date()
if today < start_date:
start_date = today
end_date = adjust_next_fire_to_timezone(reminders[-1]).date()
else:
start_date = end_date = today
# make sure start date is a Monday and enddate is a Sunday
start_date -= timedelta(days=start_date.weekday())
end_date += timedelta(days=6 - end_date.weekday())
while start_date <= end_date:
dates.append(start_date)
start_date += timedelta(days=1)
reminder_data = []
for reminder in reminders:
handler = reminder.handler
recipient = reminder.recipient
recipient_desc = get_recipient_name(recipient)
case = reminder.case
reminder_data.append(
{
"handler_name": handler.nickname,
"next_fire": adjust_next_fire_to_timezone(reminder),
"recipient_desc": recipient_desc,
"recipient_type": handler.recipient,
"case_id": case.case_id if case is not None else None,
"case_name": case.name if case is not None else None,
}
)
page_context.update(
{
"domain": self.domain,
"reminder_data": reminder_data,
"dates": dates,
"today": today,
"now": now,
"timezone": timezone,
"timezone_now": timezone_now,
}
)
return page_context
def case_changed_receiver(sender, case, **kwargs):
try:
handler_ids = CaseReminderHandler.get_handlers(case.domain,
ids_only=True)
if len(handler_ids) > 0:
case_changed.delay(case._id, handler_ids)
except Exception:
notify_exception(None,
message="Error in reminders case changed receiver for case %s" %
case._id)
def case_changed_receiver(sender, case, **kwargs):
try:
handler_ids = CaseReminderHandler.get_handler_ids(case.domain,
reminder_type_filter=REMINDER_TYPE_DEFAULT)
if len(handler_ids) > 0:
case_changed.delay(case._id, handler_ids)
except Exception:
notify_exception(None,
message="Error in reminders case changed receiver for case %s" %
case._id)
def reminders(self):
all_handlers = CaseReminderHandler.get_handlers(self.domain,
reminder_type_filter=REMINDER_TYPE_DEFAULT)
if not self.can_use_survey:
all_handlers = filter(
lambda x: x.method not in [METHOD_IVR_SURVEY, METHOD_SMS_SURVEY],
all_handlers
)
for handler in all_handlers:
yield self._fmt_reminder_data(handler)
def delete_broadcast(self, broadcast_id):
try:
broadcast = CaseReminderHandler.get(broadcast_id)
except:
raise Http404()
if broadcast.doc_type != 'CaseReminderHandler' or broadcast.domain != self.domain:
raise Http404()
broadcast.retire()
return HttpResponse()
def _case_changed(case_id, handler_ids):
subcases = None
case = CommCareCase.get(case_id)
for handler in CaseReminderHandler.get_handlers_from_ids(handler_ids):
if handler.start_condition_type == CASE_CRITERIA:
handler.case_changed(case)
if handler.uses_parent_case_property:
if subcases is None:
subcases = get_subcases(case)
for subcase in subcases:
handler.case_changed(subcase)
def handle(self, *labels, **options):
handlers = CaseReminderHandler.view("reminders/handlers_by_domain_case_type", include_docs=True)
print "Migrating CaseReminderHandlers"
for h in handlers:
try:
h.start_property = h.start
h.start_value = "^(ok|OK|\d\d\d\d-\d\d-\d\d)"
h.start_date = h.start
h.start_match_type = MATCH_REGEX
h.save()
except Exception as e:
print "There was an error migrating handler %s." % (h._id)
def scheduled_reminders(request, domain, template="reminders/partial/scheduled_reminders.html"):
reminders = CaseReminderHandler.get_all_reminders(domain)
dates = []
now = datetime.utcnow()
today = now.date()
if reminders:
start_date = reminders[0].next_fire.date()
if today < start_date:
start_date = today
end_date = reminders[-1].next_fire.date()
else:
start_date = end_date = today
# make sure start date is a Monday and enddate is a Sunday
start_date -= timedelta(days=start_date.weekday())
end_date += timedelta(days=6-end_date.weekday())
while start_date <= end_date:
dates.append(start_date)
start_date += timedelta(days=1)
reminder_data = []
for reminder in reminders:
handler = reminder.handler
recipient = reminder.recipient
if isinstance(recipient, CouchUser):
recipient_desc = "User '" + recipient.raw_username + "'"
elif isinstance(recipient, CommCareCase):
recipient_desc = "Case '" + recipient.name + "'"
elif isinstance(recipient, Group):
recipient_desc = "Group '" + recipient.name + "'"
elif isinstance(recipient, SurveySample):
recipient_desc = "Survey Sample '" + recipient.name + "'"
else:
recipient_desc = ""
case = reminder.case
reminder_data.append({
"handler_name" : handler.nickname,
"next_fire" : reminder.next_fire,
"recipient_desc" : recipient_desc,
"recipient_type" : handler.recipient,
"case_id" : case.get_id if case is not None else None,
"case_name" : case.name if case is not None else None,
})
return render(request, template, {
'domain': domain,
'reminder_data': reminder_data,
'dates': dates,
'today': today,
'now': now,
})
def delete_reminders_for_cases(domain, case_ids):
handler_ids = CaseReminderHandler.get_handler_ids(
domain, reminder_type_filter=REMINDER_TYPE_DEFAULT)
for ids in chunked(case_ids, 50):
keys = [[domain, handler_id, case_id]
for handler_id in handler_ids
for case_id in ids]
results = CaseReminder.get_db().view(
'reminders/by_domain_handler_case',
keys=keys,
include_docs=True
)
soft_delete_docs([row['doc'] for row in results], CaseReminder)
def _case_changed(case_id, handler_ids):
subcases = None
case = CommCareCase.get(case_id)
for handler in CaseReminderHandler.get_handlers_from_ids(handler_ids):
if handler.start_condition_type == CASE_CRITERIA:
kwargs = {}
if handler.uses_time_case_property:
kwargs = {"schedule_changed": True, "prev_definition": handler}
handler.case_changed(case, **kwargs)
if handler.uses_parent_case_property:
if subcases is None:
subcases = get_subcases(case)
for subcase in subcases:
handler.case_changed(subcase, **kwargs)
def _active_reminder_methods(self):
db = CaseReminderHandler.get_db()
key = [self.domain.name]
reminder_rules = db.view(
'reminders/handlers_by_reminder_type',
startkey=key,
endkey=key+[{}],
reduce=False
).all()
recipients = []
for reminder_doc in iter_docs(db, [r['id'] for r in reminder_rules]):
if reminder_doc['active']:
recipients.append(reminder_doc['method'])
return recipients
def broadcast(self):
try:
broadcast = CaseReminderHandler.get(self.broadcast_id)
except:
raise Http404()
if (
broadcast.doc_type != 'CaseReminderHandler' or
broadcast.domain != self.domain or
broadcast.reminder_type != REMINDER_TYPE_ONE_TIME
):
raise Http404()
return broadcast
def case_changed_receiver(sender, case, **kwargs):
try:
subcases = None
handlers = CaseReminderHandler.get_handlers(case.domain)
for handler in handlers:
if handler.start_condition_type == CASE_CRITERIA:
handler.case_changed(case)
if handler.uses_parent_case_property:
if subcases is None:
subcases = get_subcases(case)
for subcase in subcases:
handler.case_changed(subcase)
except Exception:
logging.exception("Error processing reminders case_changed_receiver for case %s" % case._id)
def format_broadcast_data(self, ids):
broadcasts = CaseReminderHandler.get_handlers_from_ids(ids)
result = []
for broadcast in broadcasts:
display = self.format_broadcast_name(broadcast)
result.append([
display,
self.format_recipients(broadcast),
self.format_content(broadcast),
broadcast._id,
reverse(EditBroadcastView.urlname, args=[self.domain, broadcast._id]),
reverse(CopyBroadcastView.urlname, args=[self.domain, broadcast._id]),
])
return result
def _case_changed(domain, case_id, handler_ids):
case = CaseAccessors(domain).get_case(case_id)
for handler in CaseReminderHandler.get_handlers_from_ids(handler_ids):
if handler.start_condition_type == CASE_CRITERIA:
kwargs = {}
if handler.uses_time_case_property:
kwargs = {
'schedule_changed': True,
'prev_definition': handler,
}
handler.case_changed(case, **kwargs)
if handler.uses_parent_case_property:
subcases = case.get_subcases(index_identifier=DEFAULT_PARENT_IDENTIFIER)
for subcase in subcases:
handler.case_changed(subcase, **kwargs)
def fire_reminders():
CaseReminderHandler.fire_reminders()
def create_new_broadcast(self):
return CaseReminderHandler(
domain=self.domain,
nickname='One-time Reminder',
reminder_type=REMINDER_TYPE_ONE_TIME,
)
def testOutbound(self):
# Send an outbound call using self.reminder1 to self.case
# and answer it
CaseReminderHandler.now = datetime(2014, 6, 23, 10, 0)
self.case.name = "case1"
self.case.save()
CaseReminderHandler.now = datetime(2014, 6, 23, 12, 0)
CaseReminderHandler.fire_reminders()
reminder = self.reminder1.get_reminder(self.case)
self.assertEquals(reminder.next_fire, datetime(2014, 6, 23, 12, 30))
call = self.get_last_outbound_call(self.case)
self.assertTrue(call.use_precached_first_response)
kookoo_session_id = call.gateway_session_id[7:]
resp = self.kookoo_in({
"cid": "0000",
"sid": kookoo_session_id,
"event": "NewCall",
})
self.assertEqual(
resp, '<response sid="%s"><collectdtmf l="1" o="3000">'
'<playtext>How do you feel today? Press 1 for good, 2 for bad.'
'</playtext></collectdtmf></response>' % kookoo_session_id)
resp = self.kookoo_in({
"cid": "0000",
"sid": kookoo_session_id,
"event": "GotDTMF",
"data": "1",
})
self.assertEqual(
resp, '<response sid="%s"><collectdtmf l="1" o="3000">'
'<playtext>Did you remember to take your meds today? Press 1 for yes, 2 for no.'
'</playtext></collectdtmf></response>' % kookoo_session_id)
resp = self.kookoo_in({
"cid": "0000",
"sid": kookoo_session_id,
"event": "GotDTMF",
"data": "2",
})
self.assertEqual(
resp,
'<response sid="%s"><hangup/></response>' % kookoo_session_id)
self.kookoo_finished({
"sid": kookoo_session_id,
"status": "answered",
"duration": "20",
})
call = CallLog.get(call._id)
self.assertTrue(call.answered)
self.assertEqual(call.duration, 20)
form = self.get_last_form_submission()
self.assertFormQuestionEquals(form, "how_feel", "1")
self.assertFormQuestionEquals(form, "take_meds", "2")
case = CommCareCase.get(self.case._id)
self.assertCasePropertyEquals(case, "how_feel", "1")
self.assertCasePropertyEquals(case, "take_meds", "2")
CaseReminderHandler.now = datetime(2014, 6, 23, 12, 30)
CaseReminderHandler.fire_reminders()
reminder = self.reminder1.get_reminder(self.case)
self.assertEquals(reminder.next_fire, datetime(2014, 6, 23, 13, 0))
last_call = self.get_last_outbound_call(self.case)
self.assertEqual(call._id, last_call._id)
# Move on to the second event which now uses an all-label form and
# should not precache the first ivr response
CaseReminderHandler.now = datetime(2014, 6, 23, 13, 0)
CaseReminderHandler.fire_reminders()
reminder = self.reminder1.get_reminder(self.case)
self.assertEquals(reminder.next_fire, datetime(2014, 6, 23, 13, 30))
call = self.get_last_outbound_call(self.case)
self.assertFalse(call.use_precached_first_response)
kookoo_session_id = call.gateway_session_id[7:]
resp = self.kookoo_in({
"cid": "0000",
"sid": kookoo_session_id,
"event": "NewCall",
})
self.assertEqual(
resp, '<response sid="%s">'
'<playtext>This is just a reminder to take your meds.'
'</playtext><hangup/></response>' % kookoo_session_id)
self.kookoo_finished({
"sid": kookoo_session_id,
"status": "answered",
"duration": "5",
})
call = CallLog.get(call._id)
self.assertTrue(call.answered)
self.assertEqual(call.duration, 5)
form = self.get_last_form_submission()
self.assertFormQuestionEquals(form, "label", "ok")
CaseReminderHandler.now = datetime(2014, 6, 23, 13, 30)
CaseReminderHandler.fire_reminders()
reminder = self.reminder1.get_reminder(self.case)
self.assertEquals(reminder.next_fire, datetime(2014, 6, 24, 12, 0))
last_call = self.get_last_outbound_call(self.case)
self.assertEqual(call._id, last_call._id)
# Now test sending outbound calls to a group of users (the owners
# of the case)
# Allow sending to unverified numbers
self.domain_obj = Domain.get(self.domain_obj._id)
self.domain_obj.send_to_duplicated_case_numbers = True
self.domain_obj.save()
CaseReminderHandler.now = datetime(2014, 6, 24, 10, 0)
self.case = CommCareCase.get(self.case._id)
self.case.name = "case2"
self.case.save()
reminder = self.reminder2.get_reminder(self.case)
self.assertEquals(reminder.next_fire, datetime(2014, 6, 24, 12, 0))
CaseReminderHandler.now = datetime(2014, 6, 24, 12, 0)
CaseReminderHandler.fire_reminders()
reminder = self.reminder2.get_reminder(self.case)
self.assertEquals(reminder.next_fire, datetime(2014, 6, 24, 12, 30))
call1 = self.get_last_outbound_call(self.user1)
self.assertTrue(call1.use_precached_first_response)
self.assertFalse(call1.answered)
call2 = self.get_last_outbound_call(self.user2)
self.assertTrue(call2.use_precached_first_response)
self.assertFalse(call2.answered)
old_call1 = call1
old_call2 = call2
CaseReminderHandler.now = datetime(2014, 6, 24, 12, 30)
CaseReminderHandler.fire_reminders()
reminder = self.reminder2.get_reminder(self.case)
self.assertEquals(reminder.next_fire, datetime(2014, 6, 24, 13, 0))
call1 = self.get_last_outbound_call(self.user1)
self.assertTrue(call1.use_precached_first_response)
self.assertNotEqual(call1._id, old_call1._id)
call2 = self.get_last_outbound_call(self.user2)
self.assertTrue(call2.use_precached_first_response)
self.assertFalse(call2.answered)
self.assertNotEqual(call2._id, old_call2._id)
kookoo_session_id = call1.gateway_session_id[7:]
resp = self.kookoo_in({
"cid": "0001",
"sid": kookoo_session_id,
"event": "NewCall",
})
self.assertEqual(
resp, '<response sid="%s"><collectdtmf l="1" o="3000">'
'<playtext>How do you feel today? Press 1 for good, 2 for bad.'
'</playtext></collectdtmf></response>' % kookoo_session_id)
resp = self.kookoo_in({
"cid": "0001",
"sid": kookoo_session_id,
"event": "GotDTMF",
"data": "2",
})
self.assertEqual(
resp, '<response sid="%s"><collectdtmf l="1" o="3000">'
'<playtext>Did you remember to take your meds today? Press 1 for yes, 2 for no.'
'</playtext></collectdtmf></response>' % kookoo_session_id)
resp = self.kookoo_in({
"cid": "0001",
"sid": kookoo_session_id,
"event": "GotDTMF",
"data": "1",
})
self.assertEqual(
resp,
'<response sid="%s"><hangup/></response>' % kookoo_session_id)
self.kookoo_finished({
"sid": kookoo_session_id,
"status": "answered",
"duration": "20",
})
call1 = CallLog.get(call1._id)
self.assertTrue(call1.answered)
self.assertEqual(call1.duration, 20)
form = self.get_last_form_submission()
self.assertFormQuestionEquals(form, "how_feel", "2")
self.assertFormQuestionEquals(form, "take_meds", "1")
self.assertEqual(form.form["meta"]["userID"], self.user1._id)
case = CommCareCase.get(self.case._id)
self.assertCasePropertyEquals(case, "how_feel", "2")
self.assertCasePropertyEquals(case, "take_meds", "1")
self.assertEqual(case.user_id, self.user1._id)
old_call1 = call1
old_call2 = call2
CaseReminderHandler.now = datetime(2014, 6, 24, 13, 0)
CaseReminderHandler.fire_reminders()
reminder = self.reminder2.get_reminder(self.case)
self.assertEquals(reminder.next_fire, datetime(2014, 6, 25, 12, 0))
call1 = self.get_last_outbound_call(self.user1)
# No new call for user1 since it was already answered
self.assertEqual(call1._id, old_call1._id)
call2 = self.get_last_outbound_call(self.user2)
self.assertTrue(call2.use_precached_first_response)
self.assertNotEqual(call2._id, old_call2._id)
kookoo_session_id = call2.gateway_session_id[7:]
resp = self.kookoo_in({
"cid": "0002",
"sid": kookoo_session_id,
"event": "NewCall",
})
self.assertEqual(
resp, '<response sid="%s"><collectdtmf l="1" o="3000">'
'<playtext>How do you feel today? Press 1 for good, 2 for bad.'
'</playtext></collectdtmf></response>' % kookoo_session_id)
resp = self.kookoo_in({
"cid": "0002",
"sid": kookoo_session_id,
"event": "GotDTMF",
"data": "1",
})
self.assertEqual(
resp, '<response sid="%s"><collectdtmf l="1" o="3000">'
'<playtext>Did you remember to take your meds today? Press 1 for yes, 2 for no.'
'</playtext></collectdtmf></response>' % kookoo_session_id)
resp = self.kookoo_in({
"cid": "0002",
"sid": kookoo_session_id,
"event": "GotDTMF",
"data": "2",
})
self.assertEqual(
resp,
'<response sid="%s"><hangup/></response>' % kookoo_session_id)
self.kookoo_finished({
"sid": kookoo_session_id,
"status": "answered",
"duration": "20",
})
call2 = CallLog.get(call2._id)
self.assertTrue(call2.answered)
self.assertEqual(call2.duration, 20)
form = self.get_last_form_submission()
self.assertFormQuestionEquals(form, "how_feel", "1")
self.assertFormQuestionEquals(form, "take_meds", "2")
self.assertEqual(form.form["meta"]["userID"], self.user2._id)
case = CommCareCase.get(self.case._id)
self.assertCasePropertyEquals(case, "how_feel", "1")
self.assertCasePropertyEquals(case, "take_meds", "2")
self.assertEqual(case.user_id, self.user2._id)
class KooKooTestCase(TouchformsTestCase):
"""
Must be run manually (see corehq.apps.sms.tests.util.TouchformsTestCase)
"""
def setUp(self):
super(KooKooTestCase, self).setUp()
self.ivr_backend = MobileBackend(
_id="MOBILE_BACKEND_KOOKOO",
outbound_module="corehq.apps.kookoo.api",
outbound_params={
"is_test": True,
"api_key": "xyz"
},
)
self.ivr_backend.save()
self.user1 = self.create_mobile_worker("user1",
"123",
"91001",
save_vn=False)
self.user2 = self.create_mobile_worker("user2",
"123",
"91002",
save_vn=False)
self.create_group("group1", [self.user1, self.user2])
self.case = CommCareCase(
domain=self.domain,
type="participant",
owner_id=self.groups[0]._id,
)
self.case.set_case_property("contact_phone_number", "91000")
self.case.set_case_property("contact_phone_number_is_verified", "1")
self.case.set_case_property("contact_ivr_backend_id",
"MOBILE_BACKEND_KOOKOO")
self.case.save()
dirname = os.path.dirname(os.path.abspath(__file__))
self.load_app("app1.json", dirname)
self.load_app("app2.json", dirname)
self.reminder1 = CaseReminderHandler(
domain=self.domain,
active=True,
case_type="participant",
method=METHOD_IVR_SURVEY,
recipient=RECIPIENT_CASE,
sample_id=None,
user_group_id=None,
user_id=None,
case_id=None,
reminder_type=REMINDER_TYPE_DEFAULT,
submit_partial_forms=True,
include_case_side_effects=False,
max_question_retries=5,
start_condition_type=CASE_CRITERIA,
start_property="name",
start_value="case1",
start_date=None,
start_offset=0,
start_match_type=MATCH_EXACT,
events=[
CaseReminderEvent(
day_num=0,
fire_time=time(12, 0),
fire_time_type=FIRE_TIME_DEFAULT,
callback_timeout_intervals=[30],
form_unique_id=self.apps[0].modules[0].forms[0].unique_id,
),
CaseReminderEvent(
day_num=0,
fire_time=time(13, 0),
fire_time_type=FIRE_TIME_DEFAULT,
callback_timeout_intervals=[30],
form_unique_id=self.apps[0].modules[0].forms[1].unique_id,
),
],
schedule_length=1,
event_interpretation=EVENT_AS_SCHEDULE,
max_iteration_count=7,
until=None,
force_surveys_to_use_triggered_case=False,
)
self.reminder1.save()
self.reminder2 = CaseReminderHandler(
domain=self.domain,
active=True,
case_type="participant",
method=METHOD_IVR_SURVEY,
recipient=RECIPIENT_OWNER,
sample_id=None,
user_group_id=None,
user_id=None,
case_id=None,
reminder_type=REMINDER_TYPE_DEFAULT,
submit_partial_forms=True,
include_case_side_effects=True,
max_question_retries=5,
start_condition_type=CASE_CRITERIA,
start_property="name",
start_value="case2",
start_date=None,
start_offset=0,
start_match_type=MATCH_EXACT,
events=[
CaseReminderEvent(
day_num=0,
fire_time=time(12, 0),
fire_time_type=FIRE_TIME_DEFAULT,
callback_timeout_intervals=[30, 30],
form_unique_id=self.apps[1].modules[0].forms[0].unique_id,
),
],
schedule_length=1,
event_interpretation=EVENT_AS_SCHEDULE,
max_iteration_count=7,
until=None,
force_surveys_to_use_triggered_case=False,
)
self.reminder2.save()
def kookoo_in(self, params):
"""
params should be a dictionary containing:
event, cid, sid, and (optionally) data
"""
params = urllib.urlencode(params)
url = "%s/kookoo/ivr/" % self.live_server_url
return urllib2.urlopen("%s?%s" % (url, params)).read()
def kookoo_finished(self, params):
"""
params should be a dictionary containing:
sid, status, and duration
"""
params = urllib.urlencode(params)
url = "%s/kookoo/ivr_finished/" % self.live_server_url
return urllib2.urlopen(url, params).read()
def testOutbound(self):
# Send an outbound call using self.reminder1 to self.case
# and answer it
CaseReminderHandler.now = datetime(2014, 6, 23, 10, 0)
self.case.name = "case1"
self.case.save()
CaseReminderHandler.now = datetime(2014, 6, 23, 12, 0)
CaseReminderHandler.fire_reminders()
reminder = self.reminder1.get_reminder(self.case)
self.assertEquals(reminder.next_fire, datetime(2014, 6, 23, 12, 30))
call = self.get_last_outbound_call(self.case)
self.assertTrue(call.use_precached_first_response)
kookoo_session_id = call.gateway_session_id[7:]
resp = self.kookoo_in({
"cid": "0000",
"sid": kookoo_session_id,
"event": "NewCall",
})
self.assertEqual(
resp, '<response sid="%s"><collectdtmf l="1" o="3000">'
'<playtext>How do you feel today? Press 1 for good, 2 for bad.'
'</playtext></collectdtmf></response>' % kookoo_session_id)
resp = self.kookoo_in({
"cid": "0000",
"sid": kookoo_session_id,
"event": "GotDTMF",
"data": "1",
})
self.assertEqual(
resp, '<response sid="%s"><collectdtmf l="1" o="3000">'
'<playtext>Did you remember to take your meds today? Press 1 for yes, 2 for no.'
'</playtext></collectdtmf></response>' % kookoo_session_id)
resp = self.kookoo_in({
"cid": "0000",
"sid": kookoo_session_id,
"event": "GotDTMF",
"data": "2",
})
self.assertEqual(
resp,
'<response sid="%s"><hangup/></response>' % kookoo_session_id)
self.kookoo_finished({
"sid": kookoo_session_id,
"status": "answered",
"duration": "20",
})
call = CallLog.get(call._id)
self.assertTrue(call.answered)
self.assertEqual(call.duration, 20)
form = self.get_last_form_submission()
self.assertFormQuestionEquals(form, "how_feel", "1")
self.assertFormQuestionEquals(form, "take_meds", "2")
case = CommCareCase.get(self.case._id)
self.assertCasePropertyEquals(case, "how_feel", "1")
self.assertCasePropertyEquals(case, "take_meds", "2")
CaseReminderHandler.now = datetime(2014, 6, 23, 12, 30)
CaseReminderHandler.fire_reminders()
reminder = self.reminder1.get_reminder(self.case)
self.assertEquals(reminder.next_fire, datetime(2014, 6, 23, 13, 0))
last_call = self.get_last_outbound_call(self.case)
self.assertEqual(call._id, last_call._id)
# Move on to the second event which now uses an all-label form and
# should not precache the first ivr response
CaseReminderHandler.now = datetime(2014, 6, 23, 13, 0)
CaseReminderHandler.fire_reminders()
reminder = self.reminder1.get_reminder(self.case)
self.assertEquals(reminder.next_fire, datetime(2014, 6, 23, 13, 30))
call = self.get_last_outbound_call(self.case)
self.assertFalse(call.use_precached_first_response)
kookoo_session_id = call.gateway_session_id[7:]
resp = self.kookoo_in({
"cid": "0000",
"sid": kookoo_session_id,
"event": "NewCall",
})
self.assertEqual(
resp, '<response sid="%s">'
'<playtext>This is just a reminder to take your meds.'
'</playtext><hangup/></response>' % kookoo_session_id)
self.kookoo_finished({
"sid": kookoo_session_id,
"status": "answered",
"duration": "5",
})
call = CallLog.get(call._id)
self.assertTrue(call.answered)
self.assertEqual(call.duration, 5)
form = self.get_last_form_submission()
self.assertFormQuestionEquals(form, "label", "ok")
CaseReminderHandler.now = datetime(2014, 6, 23, 13, 30)
CaseReminderHandler.fire_reminders()
reminder = self.reminder1.get_reminder(self.case)
self.assertEquals(reminder.next_fire, datetime(2014, 6, 24, 12, 0))
last_call = self.get_last_outbound_call(self.case)
self.assertEqual(call._id, last_call._id)
# Now test sending outbound calls to a group of users (the owners
# of the case)
# Allow sending to unverified numbers
self.domain_obj = Domain.get(self.domain_obj._id)
self.domain_obj.send_to_duplicated_case_numbers = True
self.domain_obj.save()
CaseReminderHandler.now = datetime(2014, 6, 24, 10, 0)
self.case = CommCareCase.get(self.case._id)
self.case.name = "case2"
self.case.save()
reminder = self.reminder2.get_reminder(self.case)
self.assertEquals(reminder.next_fire, datetime(2014, 6, 24, 12, 0))
CaseReminderHandler.now = datetime(2014, 6, 24, 12, 0)
CaseReminderHandler.fire_reminders()
reminder = self.reminder2.get_reminder(self.case)
self.assertEquals(reminder.next_fire, datetime(2014, 6, 24, 12, 30))
call1 = self.get_last_outbound_call(self.user1)
self.assertTrue(call1.use_precached_first_response)
self.assertFalse(call1.answered)
call2 = self.get_last_outbound_call(self.user2)
self.assertTrue(call2.use_precached_first_response)
self.assertFalse(call2.answered)
old_call1 = call1
old_call2 = call2
CaseReminderHandler.now = datetime(2014, 6, 24, 12, 30)
CaseReminderHandler.fire_reminders()
reminder = self.reminder2.get_reminder(self.case)
self.assertEquals(reminder.next_fire, datetime(2014, 6, 24, 13, 0))
call1 = self.get_last_outbound_call(self.user1)
self.assertTrue(call1.use_precached_first_response)
self.assertNotEqual(call1._id, old_call1._id)
call2 = self.get_last_outbound_call(self.user2)
self.assertTrue(call2.use_precached_first_response)
self.assertFalse(call2.answered)
self.assertNotEqual(call2._id, old_call2._id)
kookoo_session_id = call1.gateway_session_id[7:]
resp = self.kookoo_in({
"cid": "0001",
"sid": kookoo_session_id,
"event": "NewCall",
})
self.assertEqual(
resp, '<response sid="%s"><collectdtmf l="1" o="3000">'
'<playtext>How do you feel today? Press 1 for good, 2 for bad.'
'</playtext></collectdtmf></response>' % kookoo_session_id)
resp = self.kookoo_in({
"cid": "0001",
"sid": kookoo_session_id,
"event": "GotDTMF",
"data": "2",
})
self.assertEqual(
resp, '<response sid="%s"><collectdtmf l="1" o="3000">'
'<playtext>Did you remember to take your meds today? Press 1 for yes, 2 for no.'
'</playtext></collectdtmf></response>' % kookoo_session_id)
resp = self.kookoo_in({
"cid": "0001",
"sid": kookoo_session_id,
"event": "GotDTMF",
"data": "1",
})
self.assertEqual(
resp,
'<response sid="%s"><hangup/></response>' % kookoo_session_id)
self.kookoo_finished({
"sid": kookoo_session_id,
"status": "answered",
"duration": "20",
})
call1 = CallLog.get(call1._id)
self.assertTrue(call1.answered)
self.assertEqual(call1.duration, 20)
form = self.get_last_form_submission()
self.assertFormQuestionEquals(form, "how_feel", "2")
self.assertFormQuestionEquals(form, "take_meds", "1")
self.assertEqual(form.form["meta"]["userID"], self.user1._id)
case = CommCareCase.get(self.case._id)
self.assertCasePropertyEquals(case, "how_feel", "2")
self.assertCasePropertyEquals(case, "take_meds", "1")
self.assertEqual(case.user_id, self.user1._id)
old_call1 = call1
old_call2 = call2
CaseReminderHandler.now = datetime(2014, 6, 24, 13, 0)
CaseReminderHandler.fire_reminders()
reminder = self.reminder2.get_reminder(self.case)
self.assertEquals(reminder.next_fire, datetime(2014, 6, 25, 12, 0))
call1 = self.get_last_outbound_call(self.user1)
# No new call for user1 since it was already answered
self.assertEqual(call1._id, old_call1._id)
call2 = self.get_last_outbound_call(self.user2)
self.assertTrue(call2.use_precached_first_response)
self.assertNotEqual(call2._id, old_call2._id)
kookoo_session_id = call2.gateway_session_id[7:]
resp = self.kookoo_in({
"cid": "0002",
"sid": kookoo_session_id,
"event": "NewCall",
})
self.assertEqual(
resp, '<response sid="%s"><collectdtmf l="1" o="3000">'
'<playtext>How do you feel today? Press 1 for good, 2 for bad.'
'</playtext></collectdtmf></response>' % kookoo_session_id)
resp = self.kookoo_in({
"cid": "0002",
"sid": kookoo_session_id,
"event": "GotDTMF",
"data": "1",
})
self.assertEqual(
resp, '<response sid="%s"><collectdtmf l="1" o="3000">'
'<playtext>Did you remember to take your meds today? Press 1 for yes, 2 for no.'
'</playtext></collectdtmf></response>' % kookoo_session_id)
resp = self.kookoo_in({
"cid": "0002",
"sid": kookoo_session_id,
"event": "GotDTMF",
"data": "2",
})
self.assertEqual(
resp,
'<response sid="%s"><hangup/></response>' % kookoo_session_id)
self.kookoo_finished({
"sid": kookoo_session_id,
"status": "answered",
"duration": "20",
})
call2 = CallLog.get(call2._id)
self.assertTrue(call2.answered)
self.assertEqual(call2.duration, 20)
form = self.get_last_form_submission()
self.assertFormQuestionEquals(form, "how_feel", "1")
self.assertFormQuestionEquals(form, "take_meds", "2")
self.assertEqual(form.form["meta"]["userID"], self.user2._id)
case = CommCareCase.get(self.case._id)
self.assertCasePropertyEquals(case, "how_feel", "1")
self.assertCasePropertyEquals(case, "take_meds", "2")
self.assertEqual(case.user_id, self.user2._id)
def tearDown(self):
self.ivr_backend.delete()
super(KooKooTestCase, self).tearDown()
def setUp(self):
super(KooKooTestCase, self).setUp()
self.ivr_backend = MobileBackend(
_id="MOBILE_BACKEND_KOOKOO",
outbound_module="corehq.apps.kookoo.api",
outbound_params={
"is_test": True,
"api_key": "xyz"
},
)
self.ivr_backend.save()
self.user1 = self.create_mobile_worker("user1",
"123",
"91001",
save_vn=False)
self.user2 = self.create_mobile_worker("user2",
"123",
"91002",
save_vn=False)
self.create_group("group1", [self.user1, self.user2])
self.case = CommCareCase(
domain=self.domain,
type="participant",
owner_id=self.groups[0]._id,
)
self.case.set_case_property("contact_phone_number", "91000")
self.case.set_case_property("contact_phone_number_is_verified", "1")
self.case.set_case_property("contact_ivr_backend_id",
"MOBILE_BACKEND_KOOKOO")
self.case.save()
dirname = os.path.dirname(os.path.abspath(__file__))
self.load_app("app1.json", dirname)
self.load_app("app2.json", dirname)
self.reminder1 = CaseReminderHandler(
domain=self.domain,
active=True,
case_type="participant",
method=METHOD_IVR_SURVEY,
recipient=RECIPIENT_CASE,
sample_id=None,
user_group_id=None,
user_id=None,
case_id=None,
reminder_type=REMINDER_TYPE_DEFAULT,
submit_partial_forms=True,
include_case_side_effects=False,
max_question_retries=5,
start_condition_type=CASE_CRITERIA,
start_property="name",
start_value="case1",
start_date=None,
start_offset=0,
start_match_type=MATCH_EXACT,
events=[
CaseReminderEvent(
day_num=0,
fire_time=time(12, 0),
fire_time_type=FIRE_TIME_DEFAULT,
callback_timeout_intervals=[30],
form_unique_id=self.apps[0].modules[0].forms[0].unique_id,
),
CaseReminderEvent(
day_num=0,
fire_time=time(13, 0),
fire_time_type=FIRE_TIME_DEFAULT,
callback_timeout_intervals=[30],
form_unique_id=self.apps[0].modules[0].forms[1].unique_id,
),
],
schedule_length=1,
event_interpretation=EVENT_AS_SCHEDULE,
max_iteration_count=7,
until=None,
force_surveys_to_use_triggered_case=False,
)
self.reminder1.save()
self.reminder2 = CaseReminderHandler(
domain=self.domain,
active=True,
case_type="participant",
method=METHOD_IVR_SURVEY,
recipient=RECIPIENT_OWNER,
sample_id=None,
user_group_id=None,
user_id=None,
case_id=None,
reminder_type=REMINDER_TYPE_DEFAULT,
submit_partial_forms=True,
include_case_side_effects=True,
max_question_retries=5,
start_condition_type=CASE_CRITERIA,
start_property="name",
start_value="case2",
start_date=None,
start_offset=0,
start_match_type=MATCH_EXACT,
events=[
CaseReminderEvent(
day_num=0,
fire_time=time(12, 0),
fire_time_type=FIRE_TIME_DEFAULT,
callback_timeout_intervals=[30, 30],
form_unique_id=self.apps[1].modules[0].forms[0].unique_id,
),
],
schedule_length=1,
event_interpretation=EVENT_AS_SCHEDULE,
max_iteration_count=7,
until=None,
force_surveys_to_use_triggered_case=False,
)
self.reminder2.save()
handler = CaseReminderHandler(
domain=contact.domain,
reminder_type=reminder_type,
nickname="One-time Reminder",
default_lang="xx",
method=content_type,
recipient=recipient,
start_condition_type=ON_DATETIME,
start_datetime=datetime.utcnow(),
start_offset=0,
events=[
CaseReminderEvent(
day_num=0,
fire_time=time(0, 0),
form_unique_id=form_unique_id
if content_type == METHOD_SMS_SURVEY else None,
message={'xx': message} if content_type == METHOD_SMS else {},
callback_timeout_intervals=[],
)
],
schedule_length=1,
event_interpretation=EVENT_AS_OFFSET,
max_iteration_count=1,
case_id=case_id,
user_id=contact.get_id if recipient == RECIPIENT_USER else None,
sample_id=contact.get_id
if recipient == RECIPIENT_SURVEY_SAMPLE else None,
user_group_id=contact.get_id
if recipient == RECIPIENT_USER_GROUP else None,
messaging_event_id=logged_event.pk if logged_event else None,
)
def test_cache(self, check_state_mock):
# Nothing expected at first
self.assertEqual(CaseReminderHandler.get_handler_ids(self.domain), [])
# Create two reminder definitions of different types
handler1 = CaseReminderHandler(
domain=self.domain,
reminder_type=REMINDER_TYPE_DEFAULT,
)
handler1.save()
self.addCleanup(handler1.delete)
handler2 = CaseReminderHandler(
domain=self.domain,
reminder_type=REMINDER_TYPE_ONE_TIME,
)
handler2.save()
self.addCleanup(handler2.delete)
self.assertEqual(
CaseReminderHandler.get_handler_ids(
self.domain, reminder_type_filter=REMINDER_TYPE_DEFAULT),
[handler1._id])
self.assertEqual(
CaseReminderHandler.get_handler_ids(
self.domain, reminder_type_filter=REMINDER_TYPE_ONE_TIME),
[handler2._id])
self.assertEqual(
sorted(CaseReminderHandler.get_handler_ids(self.domain)),
sorted([handler1._id, handler2._id]))
# Add another with default type
handler3 = CaseReminderHandler(
domain=self.domain,
reminder_type=REMINDER_TYPE_DEFAULT,
)
handler3.save()
self.addCleanup(handler3.delete)
self.assertEqual(
sorted(
CaseReminderHandler.get_handler_ids(
self.domain, reminder_type_filter=REMINDER_TYPE_DEFAULT)),
sorted([handler1._id, handler3._id]))
self.assertEqual(
CaseReminderHandler.get_handler_ids(
self.domain, reminder_type_filter=REMINDER_TYPE_ONE_TIME),
[handler2._id])
self.assertEqual(
sorted(CaseReminderHandler.get_handler_ids(self.domain)),
sorted([handler1._id, handler2._id, handler3._id]))
# Retire the one-time reminder
handler2.retire()
self.assertEqual(
sorted(
CaseReminderHandler.get_handler_ids(
self.domain, reminder_type_filter=REMINDER_TYPE_DEFAULT)),
sorted([handler1._id, handler3._id]))
self.assertEqual(
CaseReminderHandler.get_handler_ids(
self.domain, reminder_type_filter=REMINDER_TYPE_ONE_TIME), [])
self.assertEqual(
sorted(CaseReminderHandler.get_handler_ids(self.domain)),
sorted([handler1._id, handler3._id]))
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 reminder(self):
return CaseReminderHandler.get(self.reminder_id)
def save_copy(self, new_domain_name=None, user=None, ignore=None):
from corehq.apps.app_manager.models import get_app
from corehq.apps.reminders.models import CaseReminderHandler
ignore = ignore if ignore is not None else []
if new_domain_name is not None and Domain.get_by_name(new_domain_name):
return None
db = get_db()
new_id = db.copy_doc(self.get_id)['id']
if new_domain_name is None:
new_domain_name = new_id
new_domain = Domain.get(new_id)
new_domain.name = new_domain_name
new_domain.copy_history = self.get_updated_history()
new_domain.is_snapshot = False
new_domain.snapshot_time = None
new_domain.organization = None # TODO: use current user's organization (?)
# reset stuff
new_domain.cda.signed = False
new_domain.cda.date = None
new_domain.cda.type = None
new_domain.cda.user_id = None
new_domain.cda.user_ip = None
new_domain.is_test = "none"
new_domain.internal = InternalProperties()
new_domain.creating_user = user.username if user else None
for field in self._dirty_fields:
if hasattr(new_domain, field):
delattr(new_domain, field)
new_comps = {} # a mapping of component's id to it's copy
for res in db.view('domain/related_to_domain', key=[self.name, True]):
if not self.is_snapshot and res['value']['doc_type'] in (
'Application', 'RemoteApp'):
app = get_app(self.name,
res['value']['_id']).get_latest_saved()
if app:
comp = self.copy_component(app.doc_type,
app._id,
new_domain_name,
user=user)
else:
comp = self.copy_component(res['value']['doc_type'],
res['value']['_id'],
new_domain_name,
user=user)
elif res['value']['doc_type'] not in ignore:
comp = self.copy_component(res['value']['doc_type'],
res['value']['_id'],
new_domain_name,
user=user)
else:
comp = None
if comp:
new_comps[res['value']['_id']] = comp
new_domain.save()
if user:
def add_dom_to_user(user):
user.add_domain_membership(new_domain_name, is_admin=True)
apply_update(user, add_dom_to_user)
def update_events(handler):
"""
Change the form_unique_id to the proper form for each event in a newly copied CaseReminderHandler
"""
from corehq.apps.app_manager.models import FormBase
for event in handler.events:
if not event.form_unique_id:
continue
form = FormBase.get_form(event.form_unique_id)
form_app = form.get_app()
m_index, f_index = form_app.get_form_location(form.unique_id)
form_copy = new_comps[form_app._id].get_module(
m_index).get_form(f_index)
event.form_unique_id = form_copy.unique_id
def update_for_copy(handler):
handler.active = False
update_events(handler)
if 'CaseReminderHandler' not in ignore:
for handler in CaseReminderHandler.get_handlers(new_domain_name):
apply_update(handler, update_for_copy)
return new_domain
def process_schedule_form(self):
new_handler = CaseReminderHandler(use_today_if_start_date_is_blank=False)
self.schedule_form.save(new_handler)
