def fire_email_event(reminder, handler, recipients, verified_numbers,
logged_event):
current_event = reminder.current_event
case = reminder.case
template_params = get_message_template_params(case)
email_usage = EmailUsage.get_or_create_usage_record(reminder.domain)
is_trial = domain_is_on_trial(reminder.domain)
uses_custom_content_handler, content_handler = get_custom_content_handler(
handler, logged_event)
if uses_custom_content_handler and not content_handler:
return
for recipient in recipients:
_add_recipient_to_template_params(recipient, template_params)
logged_subevent = logged_event.create_subevent(handler, reminder,
recipient)
try:
lang = recipient.get_language_code()
except Exception:
lang = None
if content_handler:
subject, message = content_handler(reminder, handler, recipient)
else:
subject = current_event.subject.get(
lang, current_event.subject[handler.default_lang])
message = current_event.message.get(
lang, current_event.message[handler.default_lang])
try:
subject = Message.render(subject, **template_params)
message = Message.render(message, **template_params)
except Exception:
logged_subevent.error(
MessagingEvent.ERROR_CANNOT_RENDER_MESSAGE)
continue
subject = subject or '(No Subject)'
if message:
try:
email_address = recipient.get_email()
except:
email_address = None
if email_address:
if is_trial and EmailUsage.get_total_count(
reminder.domain) >= TRIAL_MAX_EMAILS:
logged_subevent.error(
MessagingEvent.ERROR_TRIAL_EMAIL_LIMIT_REACHED)
continue
send_mail_async.delay(subject, message,
settings.DEFAULT_FROM_EMAIL,
[email_address])
email_usage.update_count()
else:
logged_subevent.error(MessagingEvent.ERROR_NO_EMAIL_ADDRESS)
continue
logged_subevent.completed()
def test_render_missing_references(self):
message = "Case name {case.name}, Case id {case.external_id}, Parent name {case.parent.name}"
context = {"case": {"name": "abc"}}
self.assertEqual(Message.render(message, **context), "Case name abc, Case id (?), Parent name (?)")
message = "Ref {ref1} {ref1.ref2}"
context = {"case": {"name": "abc"}}
self.assertEqual(Message.render(message, **context), "Ref (?) (?)")
def test_render_missing_references(self):
message = 'Case name {case.name}, Case id {case.external_id}, Parent name {case.parent.name}'
context = {'case': {'name': 'abc'}}
self.assertEqual(Message.render(message, **context),
'Case name abc, Case id (?), Parent name (?)')
message = 'Ref {ref1} {ref1.ref2}'
context = {'case': {'name': 'abc'}}
self.assertEqual(Message.render(message, **context), 'Ref (?) (?)')
def fire_email_event(reminder, handler, recipients, verified_numbers,
logged_event):
current_event = reminder.current_event
case = reminder.case
template_params = get_message_template_params(case)
uses_custom_content_handler, content_handler = get_custom_content_handler(
handler, logged_event)
if uses_custom_content_handler and not content_handler:
return
for recipient in recipients:
logged_subevent = logged_event.create_subevent(handler, reminder,
recipient)
try:
lang = recipient.get_language_code()
except Exception:
lang = None
if content_handler:
subject, message = content_handler(reminder, handler, recipient)
else:
subject = current_event.subject.get(
lang, current_event.subject[handler.default_lang])
message = current_event.message.get(
lang, current_event.message[handler.default_lang])
try:
subject = Message.render(subject, **template_params)
message = Message.render(message, **template_params)
except Exception:
logged_subevent.error(
MessagingEvent.ERROR_CANNOT_RENDER_MESSAGE)
continue
subject = subject or '(No Subject)'
if message:
try:
email_address = recipient.get_email()
except:
email_address = None
if email_address:
send_mail_async.delay(subject, message,
settings.DEFAULT_FROM_EMAIL,
[email_address])
else:
logged_subevent.error(MessagingEvent.ERROR_NO_EMAIL_ADDRESS)
continue
logged_subevent.completed()
def fire_email_event(reminder, handler, recipients, verified_numbers, logged_event):
current_event = reminder.current_event
case = reminder.case
template_params = get_message_template_params(case)
email_usage = EmailUsage.get_or_create_usage_record(reminder.domain)
is_trial = domain_is_on_trial(reminder.domain)
uses_custom_content_handler, content_handler = get_custom_content_handler(handler, logged_event)
if uses_custom_content_handler and not content_handler:
return
for recipient in recipients:
logged_subevent = logged_event.create_subevent(handler, reminder, recipient)
try:
lang = recipient.get_language_code()
except Exception:
lang = None
if content_handler:
subject, message = content_handler(reminder, handler, recipient)
else:
subject = current_event.subject.get(lang, current_event.subject[handler.default_lang])
message = current_event.message.get(lang, current_event.message[handler.default_lang])
try:
subject = Message.render(subject, **template_params)
message = Message.render(message, **template_params)
except Exception:
logged_subevent.error(MessagingEvent.ERROR_CANNOT_RENDER_MESSAGE)
continue
subject = subject or '(No Subject)'
if message:
try:
email_address = recipient.get_email()
except:
email_address = None
if email_address:
if is_trial and EmailUsage.get_total_count(reminder.domain) >= TRIAL_MAX_EMAILS:
logged_subevent.error(MessagingEvent.ERROR_TRIAL_EMAIL_LIMIT_REACHED)
continue
send_mail_async.delay(subject, message, settings.DEFAULT_FROM_EMAIL, [email_address])
email_usage.update_count()
else:
logged_subevent.error(MessagingEvent.ERROR_NO_EMAIL_ADDRESS)
continue
logged_subevent.completed()
def fire_sms_event(reminder,
handler,
recipients,
verified_numbers,
logged_event,
workflow=None):
current_event = reminder.current_event
case = reminder.case
template_params = get_message_template_params(case)
uses_custom_content_handler, content_handler = get_custom_content_handler(
handler, logged_event)
if uses_custom_content_handler and not content_handler:
return
domain_obj = Domain.get_by_name(reminder.domain, strict=True)
for recipient in recipients:
logged_subevent = logged_event.create_subevent(handler, reminder,
recipient)
try:
lang = recipient.get_language_code()
except Exception:
lang = None
if content_handler:
message = content_handler(reminder, handler, recipient)
else:
message = current_event.message.get(
lang, current_event.message[handler.default_lang])
try:
message = Message.render(message, **template_params)
except Exception:
logged_subevent.error(
MessagingEvent.ERROR_CANNOT_RENDER_MESSAGE)
continue
verified_number, unverified_number = get_recipient_phone_number(
reminder, recipient, verified_numbers)
if message:
metadata = MessageMetadata(
workflow=workflow or get_workflow(handler),
reminder_id=reminder._id,
messaging_subevent_id=logged_subevent.pk,
)
if verified_number is not None:
send_sms_to_verified_number(verified_number, message, metadata)
elif isinstance(recipient, CouchUser) and unverified_number:
send_sms(reminder.domain, recipient, unverified_number,
message, metadata)
elif (isinstance(recipient, CommCareCase) and unverified_number
and domain_obj.send_to_duplicated_case_numbers):
send_sms(reminder.domain, recipient, unverified_number,
message, metadata)
else:
logged_subevent.error(MessagingEvent.ERROR_NO_PHONE_NUMBER)
continue
logged_subevent.completed()
def test_render_nested_context(self):
message = 'Case name {case.name}, Parent name {case.parent.name}'
context = {'case': {'name': 'abc', 'parent': {'name': 'def'}}}
self.assertEqual(
Message.render(message, **context),
'Case name abc, Parent name def'
)
def test_render_context(self):
message = 'The EDD for client with ID {case.external_id} is approaching in {case.edd.days_until} days.'
context = {'case': {'external_id': 123, 'edd': datetime.utcnow() + timedelta(days=30)}}
self.assertEqual(
Message.render(message, **context),
'The EDD for client with ID 123 is approaching in 30 days.'
)
def test_unicode_template_params(self):
message = u'Case name {case.name}'
context = {'case': {'name': u'\u0928\u092e\u0938\u094d\u0924\u0947'}}
self.assertEqual(
Message.render(message, **context),
u'Case name \u0928\u092e\u0938\u094d\u0924\u0947'
)
def render_message(self, message, schedule_instance):
from corehq.messaging.scheduling.scheduling_partitioned.models import (
CaseAlertScheduleInstance,
CaseTimedScheduleInstance,
)
if not message:
return None
if isinstance(schedule_instance,
(CaseAlertScheduleInstance, CaseTimedScheduleInstance)):
case = CaseAccessors(schedule_instance.domain).get_case(
schedule_instance.case_id)
template_params = get_message_template_params(case)
try:
return Message.render(message, **template_params)
except:
subject = "[Scheduling] Could not render message"
notify_exception(None,
message=subject,
details={
'schedule_instance_id':
schedule_instance.schedule_instance_id,
})
return None
def fire_email_event(reminder, handler, recipients, verified_numbers, logged_event):
current_event = reminder.current_event
case = reminder.case
template_params = get_message_template_params(case)
uses_custom_content_handler, content_handler = get_custom_content_handler(handler, logged_event)
if uses_custom_content_handler and not content_handler:
return
for recipient in recipients:
logged_subevent = logged_event.create_subevent(handler, reminder, recipient)
try:
lang = recipient.get_language_code()
except Exception:
lang = None
if content_handler:
subject, message = content_handler(reminder, handler, recipient)
else:
subject = current_event.subject.get(lang, current_event.subject[handler.default_lang])
message = current_event.message.get(lang, current_event.message[handler.default_lang])
try:
subject = Message.render(subject, **template_params)
message = Message.render(message, **template_params)
except Exception:
logged_subevent.error(MessagingEvent.ERROR_CANNOT_RENDER_MESSAGE)
continue
subject = subject or "(No Subject)"
if message:
try:
email_address = recipient.get_email()
except:
email_address = None
if email_address:
send_mail_async.delay(subject, message, settings.DEFAULT_FROM_EMAIL, [email_address])
else:
logged_subevent.error(MessagingEvent.ERROR_NO_EMAIL_ADDRESS)
continue
logged_subevent.completed()
def fire_sms_event(reminder, handler, recipients, verified_numbers, logged_event, workflow=None):
current_event = reminder.current_event
case = reminder.case
template_params = get_message_template_params(case)
uses_custom_content_handler, content_handler = get_custom_content_handler(handler, logged_event)
if uses_custom_content_handler and not content_handler:
return
domain_obj = Domain.get_by_name(reminder.domain, strict=True)
for recipient in recipients:
logged_subevent = logged_event.create_subevent(handler, reminder, recipient)
try:
lang = recipient.get_language_code()
except Exception:
lang = None
if content_handler:
message = content_handler(reminder, handler, recipient)
else:
message = current_event.message.get(lang, current_event.message[handler.default_lang])
try:
message = Message.render(message, **template_params)
except Exception:
logged_subevent.error(MessagingEvent.ERROR_CANNOT_RENDER_MESSAGE)
continue
verified_number, unverified_number = get_recipient_phone_number(
reminder, recipient, verified_numbers)
if message:
metadata = MessageMetadata(
workflow=workflow or get_workflow(handler),
reminder_id=reminder._id,
messaging_subevent_id=logged_subevent.pk,
)
if verified_number is not None:
send_sms_to_verified_number(verified_number,
message, metadata, logged_subevent=logged_subevent)
elif isinstance(recipient, CouchUser) and unverified_number:
send_sms(reminder.domain, recipient, unverified_number,
message, metadata)
elif (is_commcarecase(recipient) and unverified_number and
domain_obj.send_to_duplicated_case_numbers):
send_sms(reminder.domain, recipient, unverified_number,
message, metadata)
else:
logged_subevent.error(MessagingEvent.ERROR_NO_PHONE_NUMBER)
continue
logged_subevent.completed()
def test_render_nested_context(self):
message = "Case name {case.name}, Parent name {case.parent.name}"
context = {"case": {"name": "abc", "parent": {"name": "def"}}}
self.assertEqual(Message.render(message, **context), "Case name abc, Parent name def")
def test_render_context(self):
message = "The EDD for client with ID {case.external_id} is approaching in {case.edd.days_until} days."
context = {"case": {"external_id": 123, "edd": datetime.utcnow() + timedelta(days=30)}}
self.assertEqual(
Message.render(message, **context), "The EDD for client with ID 123 is approaching in 30 days."
)
def test_unicode_template_params(self):
message = u"Case name {case.name}"
context = {"case": {"name": u"\u0928\u092e\u0938\u094d\u0924\u0947"}}
self.assertEqual(Message.render(message, **context), u"Case name \u0928\u092e\u0938\u094d\u0924\u0947")
