def process_verification(phone_number, msg, backend_id=None):
v = VerifiedNumber.by_phone(phone_number, True)
if not v:
return
if not verification_response_ok(msg.text):
return
msg.domain = v.domain
msg.couch_recipient_doc_type = v.owner_doc_type
msg.couch_recipient = v.owner_id
msg.save()
if not domain_has_privilege(msg.domain, privileges.INBOUND_SMS):
return
if backend_id:
backend = MobileBackend.load(backend_id)
else:
backend = MobileBackend.auto_load(phone_number, v.domain)
# i don't know how to dynamically instantiate this object, which may be any number of doc types...
#owner = CommCareMobileContactMixin.get(v.owner_id)
assert v.owner_doc_type == 'CommCareUser'
owner = CommCareUser.get(v.owner_id)
v = owner.save_verified_number(v.domain, phone_number, True, backend.name)
with localize(owner.language):
send_sms_to_verified_number(v, _(CONFIRM))
def process_verification(phone_number, msg, backend_id=None):
v = VerifiedNumber.by_phone(phone_number, True)
if not v:
return
if not verification_response_ok(msg.text):
return
msg.domain = v.domain
msg.couch_recipient_doc_type = v.owner_doc_type
msg.couch_recipient = v.owner_id
msg.save()
if backend_id:
backend = MobileBackend.load(backend_id)
else:
backend = MobileBackend.auto_load(phone_number, v.domain)
# i don't know how to dynamically instantiate this object, which may be any number of doc types...
#owner = CommCareMobileContactMixin.get(v.owner_id)
assert v.owner_doc_type == 'CommCareUser'
owner = CommCareUser.get(v.owner_id)
v = owner.save_verified_number(v.domain, phone_number, True, backend.name)
with localize(owner.language):
send_sms_to_verified_number(v, _(CONFIRM))
def test_multiple_country_prefixes(self):
self.assertEqual(
MobileBackend.auto_load('256800000000')._id, self.backend5._id)
self.assertEqual(
MobileBackend.auto_load('256700000000')._id, self.backend6._id)
self.assertEqual(
MobileBackend.auto_load('256750000000')._id, self.backend7._id)
def bootstrap(id=None, to_console=''):
"""
Create an instance of the test backend in the database
"""
backend = MobileBackend(domain=[],
description='test backend',
outbound_module='corehq.apps.sms.backend.test',
outbound_params={'to_console': True})
if id:
backend._id = id
backend.save(**get_safe_write_kwargs())
return backend
def get_ivr_backend(recipient, verified_number=None, unverified_number=None):
if verified_number and verified_number.ivr_backend_id:
return MobileBackend.get(verified_number.ivr_backend_id)
else:
phone_number = verified_number.phone_number if verified_number else unverified_number
phone_number = strip_plus(str(phone_number))
prefixes = settings.IVR_BACKEND_MAP.keys()
prefixes = sorted(prefixes, key=lambda x: len(x), reverse=True)
for prefix in prefixes:
if phone_number.startswith(prefix):
return MobileBackend.get(settings.IVR_BACKEND_MAP[prefix])
return None
def get_ivr_backend(recipient, verified_number=None, unverified_number=None):
if verified_number and verified_number.ivr_backend_id:
return MobileBackend.get(verified_number.ivr_backend_id)
else:
phone_number = (verified_number.phone_number
if verified_number else unverified_number)
phone_number = strip_plus(str(phone_number))
prefixes = settings.IVR_BACKEND_MAP.keys()
prefixes = sorted(prefixes, key=lambda x: len(x), reverse=True)
for prefix in prefixes:
if phone_number.startswith(prefix):
return MobileBackend.get(settings.IVR_BACKEND_MAP[prefix])
return None
def tearDownClass(cls):
MobileBackend.load_by_name(TEST_DOMAIN, TEST_BACKEND).delete()
CommCareUser.get_by_username('stella').delete()
CommCareUser.get_by_username('super').delete()
delete_all_locations()
LocationType.objects.all().delete()
for product in Product.by_domain(TEST_DOMAIN):
product.delete()
SQLProduct.objects.all().delete()
EWSGhanaConfig.for_domain(TEST_DOMAIN).delete()
DocDomainMapping.objects.all().delete()
generator.delete_all_subscriptions()
Domain.get_by_name(TEST_DOMAIN).delete()
def tearDownClass(cls):
MobileBackend.load_by_name(TEST_DOMAIN, TEST_BACKEND).delete()
CommCareUser.get_by_username('stella').delete()
CommCareUser.get_by_username('super').delete()
delete_all_locations()
LocationType.objects.all().delete()
for product in Product.by_domain(TEST_DOMAIN):
product.delete()
SQLProduct.objects.all().delete()
EWSGhanaConfig.for_domain(TEST_DOMAIN).delete()
DocDomainMapping.objects.all().delete()
generator.delete_all_subscriptions()
Domain.get_by_name(TEST_DOMAIN).delete()
def bootstrap(id=None, to_console=''):
"""
Create an instance of the test backend in the database
"""
backend = MobileBackend(
domain=[],
description='test backend',
outbound_module='corehq.apps.sms.backend.test',
outbound_params={'to_console': True}
)
if id:
backend._id = id
backend.save(**get_safe_write_kwargs())
return backend
def send_sms_with_backend(domain, phone_number, text, backend_id):
msg = SMSLog(domain=domain, phone_number=phone_number, direction=OUTGOING, date=datetime.utcnow(), text=text)
def onerror():
logging.exception("Exception while sending SMS to %s with backend %s" % (phone_number, backend_id))
return send_message_via_backend(msg, MobileBackend.load(backend_id), onerror=onerror)
def process_verification(phone_number, msg, backend_id=None):
v = VerifiedNumber.by_phone(phone_number, True)
if not v:
return
logged_event = MessagingEvent.get_current_verification_event(
v.domain, v.owner_id, phone_number)
if not logged_event:
logged_event = MessagingEvent.create_verification_event(
v.domain, v.owner)
subevent = logged_event.create_subevent_for_single_sms(
v.owner_doc_type, v.owner_id)
subevent.completed()
msg.domain = v.domain
msg.couch_recipient_doc_type = v.owner_doc_type
msg.couch_recipient = v.owner_id
msg.messaging_subevent_id = subevent.pk
msg.save()
if (not domain_has_privilege(msg.domain, privileges.INBOUND_SMS)
or not verification_response_ok(msg.text)):
return
if backend_id:
backend = MobileBackend.load(backend_id)
else:
backend = MobileBackend.auto_load(phone_number, v.domain)
assert v.owner_doc_type == 'CommCareUser'
owner = CommCareUser.get(v.owner_id)
v = owner.save_verified_number(v.domain, phone_number, True, backend.name)
logged_event.completed()
subevent = logged_event.create_subevent_for_single_sms(
v.owner_doc_type, v.owner_id)
with localize(owner.language):
send_sms_to_verified_number(
v,
_(CONFIRM),
metadata=MessageMetadata(messaging_subevent_id=subevent.pk))
subevent.completed()
def send_verification(domain, user, phone_number):
module = MobileBackend.auto_load(phone_number, domain).backend_module
reply_phone = getattr(module, 'receive_phone_number', lambda: None)()
message = OUTGOING % {
'name': user.username.split('@')[0],
'replyto': ' to %s' % util.clean_phone_number(reply_phone) if reply_phone else '',
}
api.send_sms(domain, user._id, phone_number, message)
def send_verification(domain, user, phone_number):
backend = MobileBackend.auto_load(phone_number, domain)
reply_phone = backend.reply_to_phone_number
message = OUTGOING % {
"name": user.username.split("@")[0],
"replyto": " to %s" % util.clean_phone_number(reply_phone) if reply_phone else "",
}
send_sms(domain, user, phone_number, message)
def tearDownClass(cls):
MobileBackend.load_by_name(TEST_DOMAIN, TEST_BACKEND).delete()
CommCareUser.get_by_username('stella').delete()
CommCareUser.get_by_username('bella').delete()
CommCareUser.get_by_username('trella').delete()
CommCareUser.get_by_username('msd_person').delete()
for product in Product.by_domain(TEST_DOMAIN):
product.delete()
SQLProduct.objects.all().delete()
ILSGatewayConfig.for_domain(TEST_DOMAIN).delete()
DocDomainMapping.objects.all().delete()
Location.by_site_code(TEST_DOMAIN, 'loc1').delete()
Location.by_site_code(TEST_DOMAIN, 'loc2').delete()
Location.by_site_code(TEST_DOMAIN, 'dis1').delete()
Location.by_site_code(TEST_DOMAIN, 'reg1').delete()
Location.by_site_code(TEST_DOMAIN, 'moh1').delete()
SQLLocation.objects.all().delete()
generator.delete_all_subscriptions()
Domain.get_by_name(TEST_DOMAIN).delete()
def send_verification(domain, user, phone_number):
backend = MobileBackend.auto_load(phone_number, domain)
reply_phone = backend.reply_to_phone_number
with localize(user.language):
message = _(OUTGOING) % {
'name': user.username.split('@')[0],
'replyto': ' to %s' % util.clean_phone_number(reply_phone) if reply_phone else '',
}
send_sms(domain, user, phone_number, message)
def tearDownClass(cls):
MobileBackend.load_by_name(TEST_DOMAIN, TEST_BACKEND).delete()
CommCareUser.get_by_username('stella').delete()
CommCareUser.get_by_username('bella').delete()
CommCareUser.get_by_username('trella').delete()
CommCareUser.get_by_username('msd_person').delete()
for product in Product.by_domain(TEST_DOMAIN):
product.delete()
SQLProduct.objects.all().delete()
ILSGatewayConfig.for_domain(TEST_DOMAIN).delete()
DocDomainMapping.objects.all().delete()
Location.by_site_code(TEST_DOMAIN, 'loc1').delete()
Location.by_site_code(TEST_DOMAIN, 'loc2').delete()
Location.by_site_code(TEST_DOMAIN, 'dis1').delete()
Location.by_site_code(TEST_DOMAIN, 'reg1').delete()
Location.by_site_code(TEST_DOMAIN, 'moh1').delete()
SQLLocation.objects.all().delete()
generator.delete_all_subscriptions()
Domain.get_by_name(TEST_DOMAIN).delete()
def process_verification(phone_number, text, backend_id=None):
v = VerifiedNumber.by_phone(phone_number, True)
if not v:
return
if not verification_response_ok(text):
return
if backend_id:
backend = MobileBackend.load(backend_id)
else:
backend = MobileBackend.auto_load(phone_number, v.domain)
# i don't know how to dynamically instantiate this object, which may be any number of doc types...
#owner = CommCareMobileContactMixin.get(v.owner_id)
assert v.owner_doc_type == 'CommCareUser'
owner = CommCareUser.get(v.owner_id)
owner.save_verified_number(v.domain, phone_number, True, backend._id)
api.send_sms(v.domain, owner._id, phone_number, CONFIRM)
def send_verification(domain, user, phone_number):
backend = MobileBackend.auto_load(phone_number, domain)
reply_phone = backend.reply_to_phone_number
with localize(user.language):
message = _(OUTGOING) % {
'name':
user.username.split('@')[0],
'replyto':
' to %s' %
util.clean_phone_number(reply_phone) if reply_phone else '',
}
send_sms(domain, user, phone_number, message)
def send_sms_with_backend_name(domain, phone_number, text, backend_name):
phone_number = clean_phone_number(phone_number)
msg = SMSLog(
domain=domain,
phone_number=phone_number,
direction=OUTGOING,
date=datetime.utcnow(),
text=text
)
def onerror():
logging.exception("Exception while sending SMS to %s with backend name %s from domain %s" % (phone_number, backend_name, domain))
return send_message_via_backend(msg, MobileBackend.load_by_name(domain, backend_name), onerror=onerror)
def send_sms_with_backend(domain, phone_number, text, backend_id):
msg = SMSLog(domain = domain,
phone_number = phone_number,
direction = OUTGOING,
date = datetime.utcnow(),
text = text)
if backend_id == "MOBILE_BACKEND_MACH":
try:
try:
msg.backend_api = mach_api.API_ID
except Exception:
pass
mach_api.send(msg)
msg.save()
return True
except Exception:
logging.exception("Exception while sending SMS to %s with backend %s" % (phone_number, backend_id))
return False
elif backend_id == "MOBILE_BACKEND_UNICEL":
try:
try:
msg.backend_api = unicel_api.API_ID
except Exception:
pass
unicel_api.send(msg)
msg.save()
return True
except Exception:
logging.exception("Exception while sending SMS to %s with backend %s" % (phone_number, backend_id))
return False
else:
try:
backend = MobileBackend.get(backend_id)
except Exception:
backend = None
if backend is None:
return False
try:
module = __import__(backend.outbound_module, fromlist=["send"])
try:
msg.backend_api = module.API_ID
except Exception:
pass
kwargs = backend.outbound_params
module.send(msg, **kwargs)
msg.save()
return True
except Exception as e:
logging.exception("Exception while sending SMS to %s with backend %s" % (phone_number, backend_id))
return False
def send_sms_with_backend_name(domain, phone_number, text, backend_name, metadata=None):
phone_number = clean_phone_number(phone_number)
backend = MobileBackend.load_by_name(domain, backend_name)
msg = SMSLog(
domain=domain,
phone_number=phone_number,
direction=OUTGOING,
date=datetime.utcnow(),
backend_id=backend._id,
text=text
)
add_msg_tags(msg, metadata)
return queue_outgoing_sms(msg)
def send_sms_with_backend(domain, phone_number, text, backend_id):
msg = SMSLog(domain=domain,
phone_number=phone_number,
direction=OUTGOING,
date=datetime.utcnow(),
text=text)
def onerror():
logging.exception("Exception while sending SMS to %s with backend %s" %
(phone_number, backend_id))
return send_message_via_backend(msg,
MobileBackend.load(backend_id),
onerror=onerror)
def get_backend_name(backend_id):
"""
Returns None if the backend is not found, otherwise
returns the backend's name.
"""
if not backend_id:
return None
try:
doc = MobileBackend.get_db().get(backend_id)
except ResourceNotFound:
return None
return doc.get("name", None)
def send_sms_with_backend_name(domain,
phone_number,
text,
backend_name,
metadata=None):
phone_number = clean_phone_number(phone_number)
backend = MobileBackend.load_by_name(domain, backend_name)
msg = SMSLog(domain=domain,
phone_number=phone_number,
direction=OUTGOING,
date=datetime.utcnow(),
backend_id=backend._id,
text=text)
add_msg_tags(msg, metadata)
return queue_outgoing_sms(msg)
def send_sms_with_backend_name(domain, phone_number, text, backend_name, metadata=None):
phone_number = clean_phone_number(phone_number)
backend = MobileBackend.load_by_name(domain, backend_name)
msg = SMSLog(
domain=domain,
phone_number=phone_number,
direction=OUTGOING,
date=datetime.utcnow(),
backend_id=backend._id,
text=text
)
add_msg_tags(msg, metadata)
def onerror():
logging.exception("Exception while sending SMS to %s with backend name %s from domain %s" % (phone_number, backend_name, domain))
return queue_outgoing_sms(msg, onerror=onerror)
def send_verification(domain, user, phone_number, logged_event):
backend = MobileBackend.auto_load(phone_number, domain)
reply_phone = backend.reply_to_phone_number
subevent = logged_event.create_subevent_for_single_sms(
user.doc_type,
user.get_id
)
with localize(user.language):
message = _(OUTGOING) % {
'name': user.username.split('@')[0],
'replyto': ' to %s' % util.clean_phone_number(reply_phone) if reply_phone else '',
}
send_sms(domain, user, phone_number, message,
metadata=MessageMetadata(messaging_subevent_id=subevent.pk))
subevent.completed()
def send_sms_with_backend_name(domain,
phone_number,
text,
backend_name,
metadata=None):
phone_number = clean_phone_number(phone_number)
backend = MobileBackend.load_by_name(domain, backend_name)
msg = SMSLog(domain=domain,
phone_number=phone_number,
direction=OUTGOING,
date=datetime.utcnow(),
backend_id=backend._id,
text=text)
add_msg_tags(msg, metadata)
def onerror():
logging.exception(
"Exception while sending SMS to %s with backend name %s from domain %s"
% (phone_number, backend_name, domain))
return queue_outgoing_sms(msg, onerror=onerror)
def send_verification(domain, user, phone_number, logged_event):
backend = MobileBackend.auto_load(phone_number, domain)
reply_phone = backend.reply_to_phone_number
subevent = logged_event.create_subevent_for_single_sms(
user.doc_type, user.get_id)
with localize(user.language):
message = _(OUTGOING) % {
'name':
user.username.split('@')[0],
'replyto':
' to %s' %
util.clean_phone_number(reply_phone) if reply_phone else '',
}
send_sms(domain,
user,
phone_number,
message,
metadata=MessageMetadata(messaging_subevent_id=subevent.pk))
subevent.completed()
def test_multiple_country_prefixes(self):
self.assertEqual(MobileBackend.auto_load('256800000000')._id, self.backend5._id)
self.assertEqual(MobileBackend.auto_load('256700000000')._id, self.backend6._id)
self.assertEqual(MobileBackend.auto_load('256750000000')._id, self.backend7._id)
def set_default_backend(self):
domain_object = Domain.get_by_name(self.domain)
domain_object.default_sms_backend_id = MobileBackend.load_by_name(None, 'MOBILE_BACKEND_TEST').get_id
domain_object.save()
class Command(BaseCommand):
args = ""
help = "Migrate backends to support backend refactor."
# Migrate all backends
def handle(self, *args, **options):
backends = MobileBackend.view("sms/old_mobile_backend", include_docs=True).all()
for backend in backends:
print "Processing backend %s" % backend._id
if backend._id == "MOBILE_BACKEND_UNICEL":
backend = UnicelBackend.wrap(backend.to_json())
backend.doc_type = "UnicelBackend"
backend.domain = None
backend.name = backend._id
backend.authorized_domains = []
backend.is_global = True
backend.username = settings.UNICEL_CONFIG.get("username")
backend.password = settings.UNICEL_CONFIG.get("password")
backend.sender = settings.UNICEL_CONFIG.get("sender")
backend.reply_to_phone_number = settings.UNICEL_CONFIG.get("receive_phone", None)
backend.outbound_module = None
backend.outbound_params = None
backend.save()
elif backend._id == "MOBILE_BACKEND_MACH":
backend = MachBackend.wrap(backend.to_json())
backend.doc_type = "MachBackend"
backend.domain = None
backend.name = backend._id
backend.authorized_domains = []
backend.is_global = True
backend.account_id = re.match(r".*id=(.+?)&", settings.SMS_GATEWAY_PARAMS).group(1)
backend.password = re.match(r".*pw=(.+?)&", settings.SMS_GATEWAY_PARAMS).group(1)
backend.sender_id = "DIMAGI"
backend.outbound_module = None
backend.outbound_params = None
backend.save()
elif backend.outbound_module == "corehq.apps.tropo.api":
backend = TropoBackend.wrap(backend.to_json())
backend.doc_type = "TropoBackend"
backend.domain = None
backend.name = backend._id
backend.authorized_domains = []
backend.is_global = True
backend.messaging_token = backend.outbound_params.get("messaging_token")
backend.outbound_module = None
backend.outbound_params = None
backend.save()
elif backend.outbound_module == "corehq.apps.sms.backend.http_api":
print "REMINDER: Need to set global / domain for backend %s" % backend._id
backend = HttpBackend.wrap(backend.to_json())
backend.doc_type = "HttpBackend"
backend.domain = None
backend.name = backend._id
backend.authorized_domains = []
backend.is_global = False
backend.url = backend.outbound_params.get("url")
backend.message_param = backend.outbound_params.get("message_param")
backend.number_param = backend.outbound_params.get("number_param")
backend.include_plus = backend.outbound_params.get("include_plus", False)
backend.method = backend.outbound_params.get("method", "GET")
backend.additional_params = backend.outbound_params.get("additional_params", {})
backend.outbound_module = None
backend.outbound_params = None
backend.save()
elif backend.outbound_module == "corehq.apps.sms.test_backend":
backend = TestSMSBackend.wrap(backend.to_json())
backend.doc_type = "TestSMSBackend"
backend.domain = None
backend.name = backend._id
backend.authorized_domains = []
backend.is_global = True
backend.outbound_module = None
backend.outbound_params = None
backend.save()
# If no unicel backend was present, create one
try:
MobileBackend.get("MOBILE_BACKEND_UNICEL")
except ResourceNotFound:
backend = UnicelBackend(
domain = None,
name = "MOBILE_BACKEND_UNICEL",
authorized_domains = [],
is_global = True,
username = settings.UNICEL_CONFIG.get("username"),
password = settings.UNICEL_CONFIG.get("password"),
sender = settings.UNICEL_CONFIG.get("sender"),
reply_to_phone_number = settings.UNICEL_CONFIG.get("receive_phone", None),
)
backend._id = backend.name
backend.save()
# If no mach backend was present, create one
try:
MobileBackend.get("MOBILE_BACKEND_MACH")
except ResourceNotFound:
backend = MachBackend(
domain = None,
name = "MOBILE_BACKEND_MACH",
authorized_domains = [],
is_global = True,
account_id = re.match(r".*id=(.+?)&", settings.SMS_GATEWAY_PARAMS).group(1),
password = re.match(r".*pw=(.+?)&", settings.SMS_GATEWAY_PARAMS).group(1),
sender_id = "DIMAGI",
)
backend._id = backend.name
backend.save()
# If no test backend was present, create one
try:
MobileBackend.get("MOBILE_BACKEND_TEST")
except ResourceNotFound:
backend = TestSMSBackend(
domain = None,
name = "MOBILE_BACKEND_TEST",
authorized_domains = [],
is_global = True,
)
backend._id = backend.name
backend.save()
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])
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()
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])
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 = CommCareCase.get(
register_sms_contact(
self.domain,
'participant',
'case1',
self.user1._id,
'91000',
owner_id=self.groups[0]._id,
))
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(
register_sms_contact(
self.domain,
'participant',
'case2',
self.user1._id,
'91003',
owner_id=self.groups[0]._id,
))
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()
def set_default_backend(self):
domain_object = Domain.get_by_name(self.domain)
domain_object.default_sms_backend_id = MobileBackend.load_by_name(
None, 'MOBILE_BACKEND_TEST').get_id
domain_object.save()
def handle(self, *args, **options):
backends = MobileBackend.view("sms/old_mobile_backend", include_docs=True).all()
for backend in backends:
print "Processing backend %s" % backend._id
if backend._id == "MOBILE_BACKEND_UNICEL":
backend = UnicelBackend.wrap(backend.to_json())
backend.doc_type = "UnicelBackend"
backend.domain = None
backend.name = backend._id
backend.authorized_domains = []
backend.is_global = True
backend.username = settings.UNICEL_CONFIG.get("username")
backend.password = settings.UNICEL_CONFIG.get("password")
backend.sender = settings.UNICEL_CONFIG.get("sender")
backend.reply_to_phone_number = settings.UNICEL_CONFIG.get("receive_phone", None)
backend.outbound_module = None
backend.outbound_params = None
backend.save()
elif backend._id == "MOBILE_BACKEND_MACH":
backend = MachBackend.wrap(backend.to_json())
backend.doc_type = "MachBackend"
backend.domain = None
backend.name = backend._id
backend.authorized_domains = []
backend.is_global = True
backend.account_id = re.match(r".*id=(.+?)&", settings.SMS_GATEWAY_PARAMS).group(1)
backend.password = re.match(r".*pw=(.+?)&", settings.SMS_GATEWAY_PARAMS).group(1)
backend.sender_id = "DIMAGI"
backend.outbound_module = None
backend.outbound_params = None
backend.save()
elif backend.outbound_module == "corehq.apps.tropo.api":
backend = TropoBackend.wrap(backend.to_json())
backend.doc_type = "TropoBackend"
backend.domain = None
backend.name = backend._id
backend.authorized_domains = []
backend.is_global = True
backend.messaging_token = backend.outbound_params.get("messaging_token")
backend.outbound_module = None
backend.outbound_params = None
backend.save()
elif backend.outbound_module == "corehq.apps.sms.backend.http_api":
print "REMINDER: Need to set global / domain for backend %s" % backend._id
backend = HttpBackend.wrap(backend.to_json())
backend.doc_type = "HttpBackend"
backend.domain = None
backend.name = backend._id
backend.authorized_domains = []
backend.is_global = False
backend.url = backend.outbound_params.get("url")
backend.message_param = backend.outbound_params.get("message_param")
backend.number_param = backend.outbound_params.get("number_param")
backend.include_plus = backend.outbound_params.get("include_plus", False)
backend.method = backend.outbound_params.get("method", "GET")
backend.additional_params = backend.outbound_params.get("additional_params", {})
backend.outbound_module = None
backend.outbound_params = None
backend.save()
elif backend.outbound_module == "corehq.apps.sms.test_backend":
backend = TestSMSBackend.wrap(backend.to_json())
backend.doc_type = "TestSMSBackend"
backend.domain = None
backend.name = backend._id
backend.authorized_domains = []
backend.is_global = True
backend.outbound_module = None
backend.outbound_params = None
backend.save()
def set_default_backend(self):
domain_object = Domain.get_by_name(self.domain)
domain_object.default_sms_backend_id = MobileBackend.load_by_name(None, 'MOBILE_BACKEND_TEST').get_id
domain_object.send_to_duplicated_case_numbers = True
domain_object.save()
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)
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)
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(call.answered)
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(call.answered)
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()
