class TestProcessMessageStatus(TestCase):
def setUp(self):
super(TestProcessMessageStatus, self).setUp()
self.backend = SQLTelerivetBackend(
name='TELERIVET',
is_global=True,
hq_api_id=SQLTelerivetBackend.get_api_id())
self.backend.set_extra_fields(
webhook_secret='The chamber of webhook secrets')
self.backend.save()
self.sms = SMS(
text='I am testy',
custom_metadata={'case_id': '123'},
)
self.sms.save()
def tearDown(self):
self.sms.delete()
super(TestProcessMessageStatus, self).tearDown()
def test_status_delivered(self):
process_message_status(self.sms, DELIVERED)
sms = SMS.objects.get(couch_id=self.sms.couch_id)
self.assertTrue('gateway_delivered' in sms.custom_metadata.keys())
def test_error_status(self):
message_id = self.sms.couch_id
process_message_status(self.sms,
FAILED,
error_message='Somthing went wrong')
sms = SMS.objects.get(couch_id=message_id)
self.assertTrue('gateway_delivered' not in sms.custom_metadata.keys())
def _get_fake_sms(self, text):
msg = SMS(domain=self.domain,
phone_number='+16175555454',
direction=OUTGOING,
date=datetime.utcnow(),
backend_id=self.mobile_backend.couch_id,
text=text)
msg.save()
return msg
def _get_fake_sms(self, text):
msg = SMS(
domain=self.domain,
phone_number='+16175555454',
direction=OUTGOING,
date=datetime.utcnow(),
backend_id=self.mobile_backend.couch_id,
text=text
)
msg.save()
return msg
def create_fake_sms(self, backend_api_id, backend_couch_id, text, date):
msg = SMS(domain=self.domain,
phone_number='+12223334444',
direction=OUTGOING,
date=date,
backend_api=backend_api_id,
backend_id=backend_couch_id,
backend_message_id=uuid.uuid4().hex,
text=text)
msg.save()
return msg
def setUp(self):
self.backend = SQLTelerivetBackend(
name='TELERIVET',
is_global=True,
hq_api_id=SQLTelerivetBackend.get_api_id())
self.backend.set_extra_fields(
webhook_secret='The chamber of webhook secrets')
self.backend.save()
self.sms = SMS(phone_number='27845698785', text="Fame is fickle")
self.sms.save()
def get_fake_sms(domain, backend_api_id, backend_couch_id, text):
msg = SMS(domain=domain,
phone_number='+12223334444',
direction=OUTGOING,
date=datetime.utcnow(),
backend_api=backend_api_id,
backend_id=backend_couch_id,
backend_message_id=uuid.uuid4().hex,
text=text)
msg.save()
return msg
def setUp(self):
self.domain = Domain(name='mockdomain')
self.domain.save()
SMS.by_domain(self.domain.name).delete()
self.user = '******'
self.password = '******'
self.number = 5555551234
self.couch_user = WebUser.create(self.domain.name, self.user, self.password)
self.couch_user.add_phone_number(self.number)
self.couch_user.save()
self.message_ascii = 'It Works'
self.message_utf_hex = '0939093F0928094D092609400020091509300924093E00200939094800200907093800200938092E092F00200915093E092E002009390948003F'
def setUp(self):
self.domain = Domain(name='mockdomain')
self.domain.save()
SMS.by_domain(self.domain.name).delete()
self.user = '******'
self.password = '******'
self.number = 5555551234
self.couch_user = WebUser.create(self.domain.name, self.user, self.password)
self.couch_user.add_phone_number(self.number)
self.couch_user.save()
self.message_ascii = 'It Works'
self.message_utf_hex = '0939093F0928094D092609400020091509300924093E00200939094800200907093800200938092E092F00200915093E092E002009390948003F'
def main_context(self):
contacts = CommCareUser.by_domain(self.domain, reduce=True)
web_users = WebUser.by_domain(self.domain)
web_users_admins = web_users_read_only = 0
facilities = SQLLocation.objects.filter(domain=self.domain, location_type__name__iexact='FACILITY')
admin_role_list = UserRole.by_domain_and_name(self.domain, 'Administrator')
if admin_role_list:
admin_role = admin_role_list[0]
else:
admin_role = None
for web_user in web_users:
dm = web_user.get_domain_membership(self.domain)
if admin_role and dm.role_id == admin_role.get_id:
web_users_admins += 1
else:
web_users_read_only += 1
main_context = super(GlobalStats, self).main_context
entities_reported_stock = SQLLocation.objects.filter(
domain=self.domain,
location_type__administrative=False
).count()
context = {
'root_name': self.root_name,
'country': SQLLocation.objects.filter(domain=self.domain,
location_type__name__iexact=self.root_name).count(),
'region': SQLLocation.objects.filter(domain=self.domain, location_type__name__iexact='region').count(),
'district': SQLLocation.objects.filter(
domain=self.domain,
location_type__name__iexact='district'
).count(),
'entities_reported_stock': entities_reported_stock,
'facilities': len(facilities),
'contacts': contacts[0]['value'] if contacts else 0,
'web_users': len(web_users),
'web_users_admins': web_users_admins,
'web_users_read_only': web_users_read_only,
'products': SQLProduct.objects.filter(domain=self.domain, is_archived=False).count(),
'product_stocks': StockState.objects.filter(sql_product__domain=self.domain).count(),
'stock_transactions': StockTransaction.objects.filter(report__domain=self.domain).count(),
'inbound_messages': SMS.count_by_domain(self.domain, direction=INCOMING),
'outbound_messages': SMS.count_by_domain(self.domain, direction=OUTGOING),
}
if self.show_supply_point_types:
counts = SQLLocation.objects.values('location_type__name').filter(domain=self.domain).annotate(
Count('location_type')
).order_by('location_type__name')
context['location_types'] = counts
main_context.update(context)
return main_context
def main_context(self):
contacts = CommCareUser.by_domain(self.domain, reduce=True)
web_users = WebUser.by_domain(self.domain)
web_users_admins = web_users_read_only = 0
facilities = SQLLocation.objects.filter(domain=self.domain, location_type__name__iexact='FACILITY')
admin_role_list = UserRole.by_domain_and_name(self.domain, 'Administrator')
if admin_role_list:
admin_role = admin_role_list[0]
else:
admin_role = None
for web_user in web_users:
dm = web_user.get_domain_membership(self.domain)
if admin_role and dm.role_id == admin_role.get_id:
web_users_admins += 1
else:
web_users_read_only += 1
main_context = super(GlobalStats, self).main_context
entities_reported_stock = SQLLocation.objects.filter(
domain=self.domain,
location_type__administrative=False
).count()
context = {
'root_name': self.root_name,
'country': SQLLocation.objects.filter(domain=self.domain,
location_type__name__iexact=self.root_name).count(),
'region': SQLLocation.objects.filter(domain=self.domain, location_type__name__iexact='region').count(),
'district': SQLLocation.objects.filter(
domain=self.domain,
location_type__name__iexact='district'
).count(),
'entities_reported_stock': entities_reported_stock,
'facilities': len(facilities),
'contacts': contacts[0]['value'] if contacts else 0,
'web_users': len(web_users),
'web_users_admins': web_users_admins,
'web_users_read_only': web_users_read_only,
'products': SQLProduct.objects.filter(domain=self.domain, is_archived=False).count(),
'product_stocks': StockState.objects.filter(sql_product__domain=self.domain).count(),
'stock_transactions': StockTransaction.objects.filter(report__domain=self.domain).count(),
'inbound_messages': SMS.count_by_domain(self.domain, direction=INCOMING),
'outbound_messages': SMS.count_by_domain(self.domain, direction=OUTGOING),
}
if self.show_supply_point_types:
counts = SQLLocation.objects.values('location_type__name').filter(domain=self.domain).annotate(
Count('location_type')
).order_by('location_type__name')
context['location_types'] = counts
main_context.update(context)
return main_context
def tearDown(self):
SmsBillable.objects.all().delete()
SmsGatewayFee.objects.all().delete()
SmsGatewayFeeCriteria.objects.all().delete()
SmsUsageFee.objects.all().delete()
SmsUsageFeeCriteria.objects.all().delete()
self.currency_usd.delete()
self.other_currency.delete()
SMS.by_domain(generator.TEST_DOMAIN).delete()
for api_id, backend_id in self.backend_ids.iteritems():
SQLMobileBackend.load(backend_id, is_couch_id=True).delete()
def testSMSSync(self):
prev_couch_count = self.getSMSLogCount()
prev_sql_count = self.getSMSCount()
# Test Create
sms = SMS()
self.setRandomSMSValues(sms)
sms.save()
sleep(1)
self.assertEqual(self.getSMSLogCount(), prev_couch_count + 1)
self.assertEqual(self.getSMSCount(), prev_sql_count + 1)
smslog = FRISMSLog.get(sms.couch_id)
self.checkFieldValues(smslog, sms, SMS._migration_get_fields())
self.assertTrue(FRISMSLog.get_db().get_rev(
smslog._id).startswith('2-'))
# Test Update
self.setRandomSMSValues(sms)
sms.save()
sleep(1)
self.assertEqual(self.getSMSLogCount(), prev_couch_count + 1)
self.assertEqual(self.getSMSCount(), prev_sql_count + 1)
smslog = FRISMSLog.get(sms.couch_id)
self.checkFieldValues(smslog, sms, SMS._migration_get_fields())
self.assertTrue(FRISMSLog.get_db().get_rev(
smslog._id).startswith('3-'))
def setUp(self):
super(TestProcessMessageStatus, self).setUp()
self.backend = SQLTelerivetBackend(
name='TELERIVET',
is_global=True,
hq_api_id=SQLTelerivetBackend.get_api_id())
self.backend.set_extra_fields(
webhook_secret='The chamber of webhook secrets')
self.backend.save()
self.sms = SMS(
text='I am testy',
custom_metadata={'case_id': '123'},
)
self.sms.save()
def add_sms_count_info(self, result, days):
end_date = self.domain_now.date()
start_date = end_date - timedelta(days=days - 1)
counts = SMS.get_counts_by_date(self.domain, start_date, end_date, self.timezone.zone)
inbound_counts = {}
outbound_counts = {}
for row in counts:
if row.direction == INCOMING:
inbound_counts[row.date] = row.sms_count
elif row.direction == OUTGOING:
outbound_counts[row.date] = row.sms_count
inbound_values = []
outbound_values = []
for i in range(days):
dt = start_date + timedelta(days=i)
inbound_values.append({
'x': dt.strftime('%Y-%m-%d'),
'y': inbound_counts.get(dt, 0),
})
outbound_values.append({
'x': dt.strftime('%Y-%m-%d'),
'y': outbound_counts.get(dt, 0),
})
result['sms_count_data'] = [
{'key': _("Incoming"), 'values': inbound_values},
{'key': _("Outgoing"), 'values': outbound_values},
]
def handle(self, domains, **options):
for domain in domains:
print("*** Processing Domain %s ***" % domain)
user_cache = {}
for msg in SMS.by_domain(domain):
if msg.couch_recipient:
if msg.couch_recipient_doc_type != "CommCareCase":
user = None
if msg.couch_recipient in user_cache:
user = user_cache[msg.couch_recipient]
else:
try:
user = CouchUser.get_by_user_id(
msg.couch_recipient)
except Exception:
user = None
if user is None:
print("Could not find user %s" %
msg.couch_recipient)
user_cache[msg.couch_recipient] = user
if user and msg.couch_recipient_doc_type != user.doc_type:
msg.couch_recipient_doc_type = user.doc_type
msg.save()
else:
if msg.couch_recipient_doc_type is not None or msg.couch_recipient is not None:
msg.couch_recipient = None
msg.couch_recipient_doc_type = None
msg.save()
def handle_domain_specific_delays(msg, domain_object, utcnow):
"""
Checks whether or not we need to hold off on sending an outbound message
due to any restrictions set on the domain, and delays processing of the
message if necessary.
Returns True if a delay was made, False if not.
"""
domain_now = ServerTime(utcnow).user_time(domain_object.get_default_timezone()).done()
if len(domain_object.restricted_sms_times) > 0:
if not time_within_windows(domain_now, domain_object.restricted_sms_times):
delay_processing(msg, settings.SMS_QUEUE_DOMAIN_RESTRICTED_RETRY_INTERVAL)
return True
if msg.chat_user_id is None and len(domain_object.sms_conversation_times) > 0:
if time_within_windows(domain_now, domain_object.sms_conversation_times):
sms_conversation_length = domain_object.sms_conversation_length
conversation_start_timestamp = utcnow - timedelta(minutes=sms_conversation_length)
if SMS.inbound_entry_exists(
msg.couch_recipient_doc_type,
msg.couch_recipient,
conversation_start_timestamp,
to_timestamp=utcnow
):
delay_processing(msg, 1)
return True
return False
def test_get_inbound_phone_entry__no_backend_id(self):
sms = SMS(phone_number=self.phone_number)
phone_number, has_domain_two_way_scope = get_inbound_phone_entry_from_sms(
sms)
self.assertEqual(phone_number.owner_id, "fake-owner-1")
self.assertFalse(has_domain_two_way_scope)
def get_participant_messages(self, case):
return SMS.by_recipient(
'CommCareCase',
case.get_id
).filter(
direction=OUTGOING
)
def handle_domain_specific_delays(msg, domain_object, utcnow):
"""
Checks whether or not we need to hold off on sending an outbound message
due to any restrictions set on the domain, and delays processing of the
message if necessary.
Returns True if a delay was made, False if not.
"""
domain_now = ServerTime(utcnow).user_time(
domain_object.get_default_timezone()).done()
if len(domain_object.restricted_sms_times) > 0:
if not time_within_windows(domain_now,
domain_object.restricted_sms_times):
delay_processing(
msg, settings.SMS_QUEUE_DOMAIN_RESTRICTED_RETRY_INTERVAL)
return True
if msg.chat_user_id is None and len(
domain_object.sms_conversation_times) > 0:
if time_within_windows(domain_now,
domain_object.sms_conversation_times):
sms_conversation_length = domain_object.sms_conversation_length
conversation_start_timestamp = utcnow - timedelta(
minutes=sms_conversation_length)
if SMS.inbound_entry_exists(msg.couch_recipient_doc_type,
msg.couch_recipient,
conversation_start_timestamp,
to_timestamp=utcnow):
delay_processing(msg, 1)
return True
return False
def _get_inbound_phone_entry__backend_domain_2(self):
"""The utilities main objective is to ensure consistency between the various
test methods that are testing `get_inbound_phone_entry` under different conditions
"""
sms = SMS(phone_number=self.phone_number,
backend_id=self.domain2_backend.couch_id)
return get_inbound_phone_entry_from_sms(sms)
def get_first_survey_response(self, case, dt):
timestamp_start = datetime.combine(dt, time(20, 45))
timestamp_start = UserTime(
timestamp_start, self.timezone).server_time().done()
timestamp_end = datetime.combine(dt + timedelta(days=1), time(11, 45))
timestamp_end = UserTime(
timestamp_end, self.timezone).server_time().done()
if timestamp_end > datetime.utcnow():
return RESPONSE_NOT_APPLICABLE
survey_responses = SMS.by_recipient(
'CommCareCase',
case.get_id
).filter(
direction=INCOMING,
xforms_session_couch_id__isnull=False,
date__gte=timestamp_start,
date__lte=timestamp_end
).order_by('date')[:1]
if survey_responses:
return survey_responses[0]
return NO_RESPONSE
def add_sms_count_info(self, result, days):
end_date = self.domain_now.date()
start_date = end_date - timedelta(days=days - 1)
counts = SMS.get_counts_by_date(self.domain, start_date, end_date, self.timezone.zone)
inbound_counts = {}
outbound_counts = {}
for row in counts:
if row.direction == INCOMING:
inbound_counts[row.date] = row.sms_count
elif row.direction == OUTGOING:
outbound_counts[row.date] = row.sms_count
inbound_values = []
outbound_values = []
for i in range(days):
dt = start_date + timedelta(days=i)
inbound_values.append({
'x': dt.strftime('%Y-%m-%d'),
'y': inbound_counts.get(dt, 0),
})
outbound_values.append({
'x': dt.strftime('%Y-%m-%d'),
'y': outbound_counts.get(dt, 0),
})
result['sms_count_data'] = [
{'key': _("Incoming"), 'values': inbound_values},
{'key': _("Outgoing"), 'values': outbound_values},
]
def rows(self):
data = SMS.by_domain(self.domain,
start_date=self.datespan.startdate_utc,
end_date=self.datespan.enddate_utc).filter(
workflow__iexact=WORKFLOW_DEFAULT).exclude(
direction=OUTGOING,
processed=False,
).order_by('date')
result = []
direction_map = {
INCOMING: _("Incoming"),
OUTGOING: _("Outgoing"),
}
reporting_locations_id = self.get_location_filter()
contact_cache = {}
for message in data:
if reporting_locations_id and message.location_id not in reporting_locations_id:
continue
doc_info = self.get_recipient_info(message, contact_cache)
phone_number = message.phone_number
timestamp = ServerTime(message.date).user_time(
self.timezone).done()
result.append([
self._fmt_timestamp(timestamp),
self._fmt_contact_link(message, doc_info),
_fmt(phone_number),
_fmt(direction_map.get(message.direction, "-")),
_fmt(message.text)
])
return result
def handle(self, domains, **options):
for domain in domains:
print("*** Processing Domain %s ***" % domain)
user_cache = {}
for msg in SMS.by_domain(domain):
if msg.couch_recipient:
if msg.couch_recipient_doc_type != "CommCareCase":
user = None
if msg.couch_recipient in user_cache:
user = user_cache[msg.couch_recipient]
else:
try:
user = CouchUser.get_by_user_id(msg.couch_recipient)
except Exception:
user = None
if user is None:
print("Could not find user %s" % msg.couch_recipient)
user_cache[msg.couch_recipient] = user
if user and msg.couch_recipient_doc_type != user.doc_type:
msg.couch_recipient_doc_type = user.doc_type
msg.save()
else:
if msg.couch_recipient_doc_type is not None or msg.couch_recipient is not None:
msg.couch_recipient = None
msg.couch_recipient_doc_type = None
msg.save()
def handle(self, *args, **options):
if len(args) == 0:
raise CommandError("Usage: python manage.py fix_smslog_recipient_doc_type <domain1 domain2 ...>")
for domain in args:
print "*** Processing Domain %s ***" % domain
user_cache = {}
for msg in SMS.by_domain(domain):
if msg.couch_recipient:
if msg.couch_recipient_doc_type != "CommCareCase":
user = None
if msg.couch_recipient in user_cache:
user = user_cache[msg.couch_recipient]
else:
try:
user = CouchUser.get_by_user_id(msg.couch_recipient)
except Exception:
user = None
if user is None:
print "Could not find user %s" % msg.couch_recipient
user_cache[msg.couch_recipient] = user
if user and msg.couch_recipient_doc_type != user.doc_type:
msg.couch_recipient_doc_type = user.doc_type
msg.save()
else:
if msg.couch_recipient_doc_type is not None or msg.couch_recipient is not None:
msg.couch_recipient = None
msg.couch_recipient_doc_type = None
msg.save()
def handle(self, *args, **options):
if len(args) == 0:
raise CommandError(
"Usage: python manage.py fix_smslog_recipient_doc_type <domain1 domain2 ...>"
)
for domain in args:
print "*** Processing Domain %s ***" % domain
user_cache = {}
for msg in SMS.by_domain(domain):
if msg.couch_recipient:
if msg.couch_recipient_doc_type != "CommCareCase":
user = None
if msg.couch_recipient in user_cache:
user = user_cache[msg.couch_recipient]
else:
try:
user = CouchUser.get_by_user_id(
msg.couch_recipient)
except Exception:
user = None
if user is None:
print "Could not find user %s" % msg.couch_recipient
user_cache[msg.couch_recipient] = user
if user and msg.couch_recipient_doc_type != user.doc_type:
msg.couch_recipient_doc_type = user.doc_type
msg.save()
else:
if msg.couch_recipient_doc_type is not None or msg.couch_recipient is not None:
msg.couch_recipient = None
msg.couch_recipient_doc_type = None
msg.save()
def tearDown(self):
SmsBillable.objects.all().delete()
SmsGatewayFee.objects.all().delete()
SmsGatewayFeeCriteria.objects.all().delete()
SmsUsageFee.objects.all().delete()
SmsUsageFeeCriteria.objects.all().delete()
self.currency_usd.delete()
self.other_currency.delete()
SMS.by_domain(generator.TEST_DOMAIN).delete()
for api_id, backend_id in self.backend_ids.iteritems():
SQLMobileBackend.load(backend_id, is_couch_id=True).delete()
FakeTwilioMessageFactory.backend_message_id_to_price = {}
super(TestGatewayFee, self).tearDown()
def tearDown(self):
SmsBillable.objects.all().delete()
SmsGatewayFee.objects.all().delete()
SmsGatewayFeeCriteria.objects.all().delete()
SmsUsageFee.objects.all().delete()
SmsUsageFeeCriteria.objects.all().delete()
self.currency_usd.delete()
self.other_currency.delete()
SMS.by_domain(generator.TEST_DOMAIN).delete()
for api_id, backend_id in six.iteritems(self.backend_ids):
SQLMobileBackend.load(backend_id, is_couch_id=True).delete()
FakeTwilioMessageFactory.backend_message_id_to_price = {}
super(TestGatewayFee, self).tearDown()
def testSMSSync(self):
self.deleteAllLogs()
self.assertEqual(self.getSMSLogCount(), 0)
self.assertEqual(self.getSMSCount(), 0)
# Test Create
sms = SMS()
self.setRandomSMSValues(sms)
sms.save()
sleep(1)
self.assertEqual(self.getSMSLogCount(), 1)
self.assertEqual(self.getSMSCount(), 1)
smslog = FRISMSLog.get(sms.couch_id)
self.checkFieldValues(smslog, sms, SMS._migration_get_fields())
self.assertTrue(FRISMSLog.get_db().get_rev(smslog._id).startswith('2-'))
# Test Update
self.setRandomSMSValues(sms)
sms.save()
sleep(1)
self.assertEqual(self.getSMSLogCount(), 1)
self.assertEqual(self.getSMSCount(), 1)
smslog = FRISMSLog.get(sms.couch_id)
self.checkFieldValues(smslog, sms, SMS._migration_get_fields())
self.assertTrue(FRISMSLog.get_db().get_rev(smslog._id).startswith('3-'))
def rows(self):
data = SMS.by_domain(
self.domain,
start_date=self.datespan.startdate_utc,
end_date=self.datespan.enddate_utc
).exclude(
direction=OUTGOING,
processed=False
).order_by('date')
if self.show_only_survey_traffic():
data = data.filter(
xforms_session_couch_id__isnull=False
)
result = []
direction_map = {
INCOMING: _("Incoming"),
OUTGOING: _("Outgoing"),
}
message_bank_messages = get_message_bank(self.domain, for_comparing=True)
FormProcessorInterface(self.domain).casedb_cache(
domain=self.domain, strip_history=False, deleted_ok=True
)
user_cache = UserCache()
for message in data:
# Add metadata from the message bank if it has not been added already
if (message.direction == OUTGOING) and (not message.fri_message_bank_lookup_completed):
add_metadata(message, message_bank_messages)
if message.couch_recipient_doc_type == "CommCareCase":
recipient = case_cache.get(message.couch_recipient)
else:
recipient = user_cache.get(message.couch_recipient)
if message.chat_user_id:
sender = user_cache.get(message.chat_user_id)
else:
sender = None
study_arm = None
if message.couch_recipient_doc_type == "CommCareCase":
study_arm = case_cache.get(message.couch_recipient).get_case_property("study_arm")
timestamp = ServerTime(message.date).user_time(self.timezone).done()
result.append([
self._fmt(self._participant_id(recipient)),
self._fmt(study_arm or "-"),
self._fmt(self._originator(message, recipient, sender)),
self._fmt_timestamp(timestamp),
self._fmt(message.text),
self._fmt(message.fri_id or "-"),
self._fmt(direction_map.get(message.direction,"-")),
])
return result
def rows(self):
data = SMS.by_domain(self.domain,
start_date=self.datespan.startdate_utc,
end_date=self.datespan.enddate_utc).exclude(
direction=OUTGOING,
processed=False).order_by('date')
if self.show_only_survey_traffic():
data = data.filter(xforms_session_couch_id__isnull=False)
result = []
direction_map = {
INCOMING: _("Incoming"),
OUTGOING: _("Outgoing"),
}
message_bank_messages = get_message_bank(self.domain,
for_comparing=True)
FormProcessorInterface(self.domain).casedb_cache(domain=self.domain,
strip_history=False,
deleted_ok=True)
user_cache = UserCache()
for message in data:
# Add metadata from the message bank if it has not been added already
if (message.direction == OUTGOING) and (
not message.fri_message_bank_lookup_completed):
add_metadata(message, message_bank_messages)
if message.couch_recipient_doc_type == "CommCareCase":
recipient = case_cache.get(message.couch_recipient)
else:
recipient = user_cache.get(message.couch_recipient)
if message.chat_user_id:
sender = user_cache.get(message.chat_user_id)
else:
sender = None
study_arm = None
if message.couch_recipient_doc_type == "CommCareCase":
study_arm = case_cache.get(
message.couch_recipient).get_case_property("study_arm")
timestamp = ServerTime(message.date).user_time(
self.timezone).done()
result.append([
self._fmt(self._participant_id(recipient)),
self._fmt(study_arm or "-"),
self._fmt(self._originator(message, recipient, sender)),
self._fmt_timestamp(timestamp),
self._fmt(message.text),
self._fmt(message.fri_id or "-"),
self._fmt(direction_map.get(message.direction, "-")),
])
return result
def _test_unicel_send(self, text, expected_msg):
message = SMS(text=text, phone_number='+15555555555')
with patch('corehq.messaging.smsbackends.unicel.models.urlopen') as patch_urlopen:
self.backend.send(message)
self.assertEqual(len(patch_urlopen.call_args_list), 1)
called_args = patch_urlopen.call_args_list[0]
url, = called_args[0]
parsed_url = urlparse(url)
url_params = parse_qs(parsed_url.query)
self.assertEqual(url_params['msg'], [expected_msg])
def test_get_inbound_phone_entry__global_backend(self):
sms = SMS(phone_number=self.phone_number,
backend_id=self.global_backend.couch_id)
phone_number, has_domain_two_way_scope = get_inbound_phone_entry_from_sms(
sms)
self.assertEqual(phone_number.owner_id, "fake-owner-1")
self.assertFalse(has_domain_two_way_scope)
self.assertTrue(
self.global_backend.domain_is_authorized(phone_number.domain))
def send_sample_sms(request, domain):
request_token = request.POST.get('request_token')
if not TelerivetSetupView.get_cached_webhook_secret(request_token):
return {
'success': False,
'unexpected_error': TelerivetSetupView.unexpected_error,
}
outgoing_sms_form = TelerivetOutgoingSMSForm({
'api_key':
request.POST.get('api_key'),
'project_id':
request.POST.get('project_id'),
'phone_id':
request.POST.get('phone_id'),
})
test_sms_form = TelerivetPhoneNumberForm({
'test_phone_number':
request.POST.get('test_phone_number'),
})
# Be sure to call .is_valid() on both
outgoing_sms_form_valid = outgoing_sms_form.is_valid()
test_sms_form_valid = test_sms_form.is_valid()
if not outgoing_sms_form_valid or not test_sms_form_valid:
return json_response({
'success':
False,
'api_key_error':
TelerivetSetupView.get_error_message(outgoing_sms_form, 'api_key'),
'project_id_error':
TelerivetSetupView.get_error_message(outgoing_sms_form,
'project_id'),
'phone_id_error':
TelerivetSetupView.get_error_message(outgoing_sms_form,
'phone_id'),
'test_phone_number_error':
TelerivetSetupView.get_error_message(test_sms_form,
'test_phone_number'),
})
tmp_backend = SQLTelerivetBackend()
tmp_backend.set_extra_fields(
api_key=outgoing_sms_form.cleaned_data.get('api_key'),
project_id=outgoing_sms_form.cleaned_data.get('project_id'),
phone_id=outgoing_sms_form.cleaned_data.get('phone_id'),
)
sms = SMS(phone_number=clean_phone_number(
test_sms_form.cleaned_data.get('test_phone_number')),
text="This is a test SMS from CommCareHQ.")
tmp_backend.send(sms)
return json_response({
'success': True,
})
def arbitrary_messages_by_backend_and_direction(backend_ids,
phone_number=None,
domain=None,
directions=DIRECTIONS):
phone_number = phone_number or TEST_NUMBER
domain = domain or TEST_DOMAIN
messages = []
for api_id, instance_id in backend_ids.items():
for direction in directions:
sms_log = SMS(
direction=direction,
phone_number=phone_number,
domain=domain,
backend_api=api_id,
backend_id=instance_id,
text=arbitrary_message(),
date=datetime.datetime.utcnow()
)
sms_log.save()
messages.append(sms_log)
return messages
def arbitrary_messages_by_backend_and_direction(backend_ids,
phone_number=None,
domain=None,
directions=None):
phone_number = phone_number or TEST_NUMBER
domain = domain or TEST_DOMAIN
directions = directions or DIRECTIONS
messages = []
for api_id, instance_id in backend_ids.items():
for direction in directions:
sms_log = SMS(direction=direction,
phone_number=phone_number,
domain=domain,
backend_api=api_id,
backend_id=instance_id,
backend_message_id=uuid.uuid4().hex,
text=arbitrary_message(),
date=datetime.datetime.utcnow())
sms_log.save()
messages.append(sms_log)
return messages
def _get_sms(self):
msg = SMS(
phone_number=self.number1.phone_number,
direction=INCOMING,
date=datetime.utcnow(),
text="test message",
domain_scope=None,
backend_api=None,
backend_id=None,
backend_message_id=None,
raw_text=None,
)
return msg
def rows(self):
data = (SMS.by_domain(self.config['domain'])
.filter(location_id=self.config['location_id'])
.order_by('date'))
messages = []
for message in data:
timestamp = ServerTime(message.date).user_time(self.config['timezone']).done()
messages.append([
_fmt_timestamp(timestamp),
_fmt(message.direction),
_fmt(message.text),
])
return messages
def _create_message(self,
domain='test_domain',
phone_number='2511234567',
direction=OUTGOING,
date=None,
text='Hello World'):
if not date:
date = datetime(2021, 5, 15)
return SMS(domain=domain,
phone_number=phone_number,
direction=direction,
date=date,
text=text)
def rows(self):
data = (SMS.by_domain(self.config['domain']).filter(
location_id=self.config['location_id']).exclude(
processed=False, direction=OUTGOING).order_by('-date'))
messages = []
for message in data:
recipient = message.recipient
timestamp = ServerTime(message.date).user_time(
self.config['timezone']).done()
messages.append([
_fmt_timestamp(timestamp),
recipient.full_name,
message.phone_number,
_fmt(message.direction),
_fmt(message.text),
])
return messages
def rows(self):
data = (SMS.by_domain(self.config['domain'])
.filter(location_id=self.config['location_id'])
.exclude(processed=False, direction=OUTGOING)
.order_by('-date'))
messages = []
for message in data:
recipient = message.recipient
timestamp = ServerTime(message.date).user_time(self.config['timezone']).done()
messages.append([
_fmt_timestamp(timestamp),
recipient.full_name,
message.phone_number,
_fmt(message.direction),
_fmt(message.text),
])
return messages
def test_incoming_sms_linked_form_session(self):
event, expected_subevent = self._create_message_event_and_subevent()
msg = SMS(
phone_number=self.number.phone_number,
direction=INCOMING,
date=datetime.utcnow(),
text="test message",
domain_scope=None,
backend_api=None,
backend_id=None,
backend_message_id=None,
raw_text=None,
)
self.addCleanup(msg.delete)
form_session_handler(self.number, msg.text, msg)
self.assertEqual(expected_subevent, msg.messaging_subevent)
def test_correctly_handles_ssrf(self, mock_save, mock_metrics_counter):
# SSRF needs to:
# - set the error on the message and save, so the message isn't re-queued
# - generate a metric
# - raise a PossibleSSRFAttempt exception
message = SMS(domain='test-domain')
# raise exception
with self.assertRaises(PossibleSSRFAttempt):
verify_sms_url('https://malicious.address', message, self.backend)
# setting error message and saving
self.assertTrue(message.error)
self.assertEqual(message.system_error_message, 'FAULTY_GATEWAY_CONFIGURATION')
mock_save.assert_called()
# generating the metric
mock_metrics_counter.assert_called_with('commcare.sms.ssrf_attempt',
tags={'domain': 'test-domain', 'src': 'SQLHttpBackend', 'reason': 'is_loopback'})
def remove_from_queue(queued_sms):
with transaction.atomic():
sms = SMS()
for field in sms._meta.fields:
if field.name != 'id':
setattr(sms, field.name, getattr(queued_sms, field.name))
queued_sms.delete()
sms.save()
sms.publish_change()
if sms.direction == OUTGOING and sms.processed and not sms.error:
create_billable_for_sms(sms)
elif sms.direction == INCOMING and sms.domain and domain_has_privilege(sms.domain, privileges.INBOUND_SMS):
create_billable_for_sms(sms)
def handle(self, start_datetime, end_datetime, **options):
num_sms = 0
for domain in Domain.get_all():
result = SMS.by_domain(
domain.name,
start_date=start_datetime,
end_date=end_datetime,
)
for sms_log in result:
if options.get('create', False):
SmsBillable.create(sms_log)
print('Created billable for SMS %s in domain %s from %s' \
% (sms_log.couch_id, domain.name, sms_log.date))
else:
print('Found SMS %s in domain %s from %s' \
% (sms_log.couch_id, domain.name, sms_log.date))
num_sms += 1
print('Number of SMSs in datetime range: %d' % num_sms)
def handle(self, start_datetime, end_datetime, **options):
num_sms = 0
for domain in Domain.get_all():
result = SMS.by_domain(
domain.name,
start_date=start_datetime,
end_date=end_datetime,
)
for sms_log in result:
if options.get('create', False):
SmsBillable.create(sms_log)
print('Created billable for SMS %s in domain %s from %s' \
% (sms_log.couch_id, domain.name, sms_log.date))
else:
print('Found SMS %s in domain %s from %s' \
% (sms_log.couch_id, domain.name, sms_log.date))
num_sms += 1
print('Number of SMSs in datetime range: %d' % num_sms)
def handle(self, *args, **options):
num_sms = 0
start_datetime = datetime.datetime(*str_to_int_tuple(args[0:6]))
end_datetime = datetime.datetime(*str_to_int_tuple(args[6:12]))
for domain in Domain.get_all():
result = SMS.by_domain(domain.name,
start_date=start_datetime,
end_date=end_datetime)
for sms_log in result:
if options.get('create', False):
SmsBillable.create(sms_log)
print 'Created billable for SMS %s in domain %s from %s' \
% (sms_log.couch_id, domain.name, sms_log.date)
else:
print 'Found SMS %s in domain %s from %s' \
% (sms_log.couch_id, domain.name, sms_log.date)
num_sms += 1
print 'Number of SMSs in datetime range: %d' % num_sms
def handle(self, *args, **options):
num_sms = 0
start_datetime = datetime.datetime(*str_to_int_tuple(args[0:6]))
end_datetime = datetime.datetime(*str_to_int_tuple(args[6:12]))
for domain in Domain.get_all():
result = SMS.by_domain(
domain.name,
start_date=start_datetime,
end_date=end_datetime
)
for sms_log in result:
if options.get('create', False):
SmsBillable.create(sms_log)
print 'Created billable for SMS %s in domain %s from %s' \
% (sms_log.couch_id, domain.name, sms_log.date)
else:
print 'Found SMS %s in domain %s from %s' \
% (sms_log.couch_id, domain.name, sms_log.date)
num_sms += 1
print 'Number of SMSs in datetime range: %d' % num_sms
def rows(self):
data = SMS.by_domain(
self.domain,
start_date=self.datespan.startdate_utc,
end_date=self.datespan.enddate_utc
).filter(
workflow__iexact=WORKFLOW_DEFAULT
).exclude(
direction=OUTGOING,
processed=False,
).order_by('date')
result = []
direction_map = {
INCOMING: _("Incoming"),
OUTGOING: _("Outgoing"),
}
reporting_locations_id = self.get_location_filter()
contact_cache = {}
for message in data:
if reporting_locations_id and message.location_id not in reporting_locations_id:
continue
doc_info = self.get_recipient_info(message, contact_cache)
phone_number = message.phone_number
timestamp = ServerTime(message.date).user_time(self.timezone).done()
result.append([
self._fmt_timestamp(timestamp),
self._fmt_contact_link(message, doc_info),
_fmt(phone_number),
_fmt(direction_map.get(message.direction, "-")),
_fmt(message.text)
])
return result
def get_last_outbound_sms(self, contact):
return SMS.get_last_log_for_recipient(
contact.doc_type,
contact.get_id,
direction=OUTGOING
)
def _migration_get_fields(cls):
return SMS._migration_get_fields()
def setUp(self):
SMS.by_domain(self.domain.name).delete()