def process_incoming(msg):
v = PhoneNumber.by_phone(msg.phone_number, include_pending=True)
if v:
msg.couch_recipient_doc_type = v.owner_doc_type
msg.couch_recipient = v.owner_id
msg.domain = v.domain
msg.location_id = get_location_id_by_verified_number(v)
msg.save()
elif msg.domain_scope:
msg.domain = msg.domain_scope
msg.save()
can_receive_sms = PhoneBlacklist.can_receive_sms(msg.phone_number)
opt_in_keywords, opt_out_keywords = get_opt_keywords(msg)
domain = v.domain if v else None
if is_opt_message(msg.text, opt_out_keywords) and can_receive_sms:
if PhoneBlacklist.opt_out_sms(msg.phone_number, domain=domain):
metadata = MessageMetadata(ignore_opt_out=True)
text = get_message(MSG_OPTED_OUT, v, context=(opt_in_keywords[0],))
if v:
send_sms_to_verified_number(v, text, metadata=metadata)
else:
send_sms(msg.domain, None, msg.phone_number, text, metadata=metadata)
elif is_opt_message(msg.text, opt_in_keywords) and not can_receive_sms:
if PhoneBlacklist.opt_in_sms(msg.phone_number, domain=domain):
text = get_message(MSG_OPTED_IN, v, context=(opt_out_keywords[0],))
if v:
send_sms_to_verified_number(v, text)
else:
send_sms(msg.domain, None, msg.phone_number, text)
else:
handled = False
is_verified = v is not None and v.verified
if msg.domain and domain_has_privilege(msg.domain, privileges.INBOUND_SMS):
handled = load_and_call(settings.CUSTOM_SMS_HANDLERS, v, msg.text, msg)
if not handled and is_verified and is_contact_active(v.domain, v.owner_doc_type, v.owner_id):
handled = load_and_call(settings.SMS_HANDLERS, v, msg.text, msg)
if not handled and not is_verified:
handled = process_pre_registration(msg)
if not handled:
handled = process_sms_registration(msg)
if not handled:
import verify
verify.process_verification(v, msg)
# If the sms queue is enabled, then the billable gets created in remove_from_queue()
if (
not settings.SMS_QUEUE_ENABLED and
msg.domain and
domain_has_privilege(msg.domain, privileges.INBOUND_SMS)
):
create_billable_for_sms(msg)
def incoming(phone_number, text, backend_api, timestamp=None, domain_scope=None, delay=True):
"""
entry point for incoming sms
phone_number - originating phone number
text - message content
backend_api - backend ID of receiving sms backend
timestamp - message received timestamp; defaults to now (UTC)
domain_scope - if present, only messages from phone numbers that can be
definitively linked to this domain will be processed; others will be
dropped (useful to provide security when simulating incoming sms)
"""
phone_number = clean_phone_number(phone_number)
v = VerifiedNumber.by_phone(phone_number, include_pending=True)
if domain_scope:
# only process messages for phones known to be associated with this domain
if v is None or v.domain != domain_scope:
raise RuntimeError("attempted to simulate incoming sms from phone number not verified with this domain")
# Log message in message log
msg = SMSLog(
phone_number=phone_number,
direction=INCOMING,
date=timestamp or datetime.utcnow(),
text=text,
backend_api=backend_api,
)
if v is not None and v.verified:
msg.couch_recipient_doc_type = v.owner_doc_type
msg.couch_recipient = v.owner_id
msg.domain = v.domain
msg.save()
create_billable_for_sms(msg, backend_api, delay=delay)
if v is not None and v.verified:
for h in settings.SMS_HANDLERS:
try:
handler = to_function(h)
except:
logging.exception("error loading sms handler: %s" % h)
continue
try:
was_handled = handler(v, text)
except:
logging.exception("unhandled error in sms handler %s for message [%s]" % (h, text))
was_handled = False
if was_handled:
break
else:
if not process_sms_registration(msg):
import verify
verify.process_verification(phone_number, text)
return msg
was_handled = handler(v, msg.text, msg=msg)
except Exception, e:
log_sms_exception(msg)
was_handled = False
if was_handled:
break
else:
handled = process_pre_registration(msg)
if not handled:
handled = process_sms_registration(msg)
if not handled:
import verify
verify.process_verification(v, msg)
# If the sms queue is enabled, then the billable gets created in remove_from_queue()
if (
not settings.SMS_QUEUE_ENABLED and
msg.domain and
domain_has_privilege(msg.domain, privileges.INBOUND_SMS)
):
create_billable_for_sms(msg)
def create_billable_for_sms(msg, delay=True):
if not isinstance(msg, SMS):
raise Exception("Expected msg to be an SMS")
if not msg.domain:
def process_incoming(msg):
v = PhoneNumber.by_phone(msg.phone_number, include_pending=True)
if v:
msg.couch_recipient_doc_type = v.owner_doc_type
msg.couch_recipient = v.owner_id
msg.domain = v.domain
msg.location_id = get_location_id_by_verified_number(v)
msg.save()
elif msg.domain_scope:
msg.domain = msg.domain_scope
msg.save()
can_receive_sms = PhoneBlacklist.can_receive_sms(msg.phone_number)
opt_in_keywords, opt_out_keywords = get_opt_keywords(msg)
domain = v.domain if v else None
if is_opt_message(msg.text, opt_out_keywords) and can_receive_sms:
if PhoneBlacklist.opt_out_sms(msg.phone_number, domain=domain):
metadata = MessageMetadata(ignore_opt_out=True)
text = get_message(MSG_OPTED_OUT,
v,
context=(opt_in_keywords[0], ))
if v:
send_sms_to_verified_number(v, text, metadata=metadata)
else:
send_sms(msg.domain,
None,
msg.phone_number,
text,
metadata=metadata)
elif is_opt_message(msg.text, opt_in_keywords) and not can_receive_sms:
if PhoneBlacklist.opt_in_sms(msg.phone_number, domain=domain):
text = get_message(MSG_OPTED_IN,
v,
context=(opt_out_keywords[0], ))
if v:
send_sms_to_verified_number(v, text)
else:
send_sms(msg.domain, None, msg.phone_number, text)
else:
handled = False
is_verified = v is not None and v.verified
if msg.domain and domain_has_privilege(msg.domain,
privileges.INBOUND_SMS):
handled = load_and_call(settings.CUSTOM_SMS_HANDLERS, v, msg.text,
msg)
if not handled and is_verified and is_contact_active(
v.domain, v.owner_doc_type, v.owner_id):
handled = load_and_call(settings.SMS_HANDLERS, v, msg.text,
msg)
if not handled and not is_verified:
handled = process_pre_registration(msg)
if not handled:
handled = process_sms_registration(msg)
if not handled:
import verify
verify.process_verification(v, msg)
# If the sms queue is enabled, then the billable gets created in remove_from_queue()
if (not settings.SMS_QUEUE_ENABLED and msg.domain
and domain_has_privilege(msg.domain, privileges.INBOUND_SMS)):
create_billable_for_sms(msg)
if msg.domain_scope:
# only process messages for phones known to be associated with this domain
if v is None or v.domain != msg.domain_scope:
raise DomainScopeValidationError(
'Attempted to simulate incoming sms from phone number not ' \
'verified with this domain'
)
create_billable_for_sms(msg, msg.backend_api, delay=delay)
if v is not None and v.verified:
for h in settings.SMS_HANDLERS:
try:
handler = to_function(h)
except:
logging.exception('error loading sms handler: %s' % h)
continue
try:
was_handled = handler(v, msg.text, msg=msg)
except Exception, e:
logging.exception('unhandled error in sms handler %s for message [%s]: %s' % (h, msg._id, e))
was_handled = False
if was_handled:
break
else:
if not process_sms_registration(msg):
import verify
verify.process_verification(msg.phone_number, msg)
message=('error loading sms handler: %s' %
h))
continue
try:
was_handled = handler(v, msg.text, msg=msg)
except Exception, e:
log_sms_exception(msg)
was_handled = False
if was_handled:
break
else:
if not process_sms_registration(msg):
import verify
verify.process_verification(msg.phone_number, msg)
if msg.domain and domain_has_privilege(msg.domain, privileges.INBOUND_SMS):
create_billable_for_sms(msg)
def create_billable_for_sms(msg, delay=True):
if not msg.domain:
return
try:
from corehq.apps.sms.tasks import store_billable
if delay:
store_billable.delay(msg)
else:
store_billable(msg)
except Exception as e:
was_handled = handler(v, msg.text, msg=msg)
except Exception, e:
log_sms_exception(msg)
was_handled = False
if was_handled:
break
else:
handled = process_pre_registration(msg)
if not handled:
handled = process_sms_registration(msg)
if not handled:
import verify
verify.process_verification(v, msg)
if msg.domain and domain_has_privilege(msg.domain, privileges.INBOUND_SMS):
create_billable_for_sms(msg)
def create_billable_for_sms(msg, delay=True):
if not msg.domain:
return
try:
from corehq.apps.sms.tasks import store_billable
if delay:
store_billable.delay(msg)
else:
store_billable(msg)
except Exception as e:
def incoming(phone_number,
text,
backend_api,
timestamp=None,
domain_scope=None,
delay=True):
"""
entry point for incoming sms
phone_number - originating phone number
text - message content
backend_api - backend ID of receiving sms backend
timestamp - message received timestamp; defaults to now (UTC)
domain_scope - if present, only messages from phone numbers that can be
definitively linked to this domain will be processed; others will be
dropped (useful to provide security when simulating incoming sms)
"""
phone_number = clean_phone_number(phone_number)
v = VerifiedNumber.by_phone(phone_number, include_pending=True)
if domain_scope:
# only process messages for phones known to be associated with this domain
if v is None or v.domain != domain_scope:
raise RuntimeError(
'attempted to simulate incoming sms from phone number not verified with this domain'
)
# Log message in message log
msg = SMSLog(phone_number=phone_number,
direction=INCOMING,
date=timestamp or datetime.utcnow(),
text=text,
backend_api=backend_api)
if v is not None and v.verified:
msg.couch_recipient_doc_type = v.owner_doc_type
msg.couch_recipient = v.owner_id
msg.domain = v.domain
msg.save()
create_billable_for_sms(msg, backend_api, delay=delay)
if v is not None and v.verified:
for h in settings.SMS_HANDLERS:
try:
handler = to_function(h)
except:
logging.exception('error loading sms handler: %s' % h)
continue
try:
was_handled = handler(v, text)
except:
logging.exception(
'unhandled error in sms handler %s for message [%s]' %
(h, text))
was_handled = False
if was_handled:
break
else:
if not process_sms_registration(msg):
import verify
verify.process_verification(phone_number, text)
return msg
