def send(msg, delay=True, *args, **kwargs):
"""
Sends a message via mach's API
"""
context = {
'phone_number': urllib.quote(msg.phone_number),
'sender_id': urllib.quote(kwargs.get("sender_id", DEFAULT_SENDER_ID)),
}
encoding_param = ""
try:
text = msg.text.encode("iso-8859-1")
context["message"] = clean_outgoing_sms_text(text)
except UnicodeEncodeError:
context["message"] = msg.text.encode("utf-16-be").encode("hex")
encoding_param = "&encoding=ucs"
url = "%s?%s%s" % (settings.SMS_GATEWAY_URL,
settings.SMS_GATEWAY_PARAMS % context, encoding_param)
# just opening the url is enough to send the message
# TODO, check response
resp = urllib2.urlopen(url).read()
msg.save()
create_billable_for_sms(msg, API_ID, delay=delay, response=resp)
return resp
def process_incoming(msg, delay=True):
v = VerifiedNumber.by_phone(msg.phone_number, include_pending=True)
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()
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
def send(message, delay=True):
"""
Send an outbound message using the Unicel API
"""
config = _config()
phone_number = clean_phone_number(message.phone_number).replace("+", "")
# these are shared regardless of API
params = [(OutboundParams.DESTINATION, phone_number),
(OutboundParams.USERNAME, config["username"]),
(OutboundParams.PASSWORD, config["password"]),
(OutboundParams.SENDER, config["sender"])]
try:
text = str(message.text)
# it's ascii
params.append((OutboundParams.MESSAGE, text))
except UnicodeEncodeError:
params.extend(UNICODE_PARAMS)
encoded = message.text.encode("utf_16_be").encode("hex").upper()
params.append((OutboundParams.MESSAGE, encoded))
try:
data = urlopen('%s?%s' % (OUTBOUND_URLBASE, urlencode(params))).read()
except Exception:
data = None
message.save()
create_billable_for_sms(message, API_ID, delay=delay, response=data)
return data
def send(msg, delay=True, *args, **kwargs):
"""
Expected kwargs:
messaging_token
"""
phone_number = msg.phone_number
if phone_number[0] != "+":
phone_number = "+" + phone_number
try:
text = str(msg.text)
except UnicodeEncodeError:
text = msg.text.encode("utf-8")
params = urlencode({
"action": "create",
"token": kwargs["messaging_token"],
"numberToDial": phone_number,
"msg": text,
"_send_sms": "true"
})
url = "https://api.tropo.com/1.0/sessions?%s" % params
response = urlopen(url).read()
msg.save()
create_billable_for_sms(msg, API_ID, delay=delay, response=response)
return response
def send(self, message, delay=True, *args, **kwargs):
"""
Send an outbound message using the Unicel API
"""
phone_number = clean_phone_number(message.phone_number).replace(
"+", "")
params = [(OutboundParams.DESTINATION, phone_number),
(OutboundParams.USERNAME, self.username),
(OutboundParams.PASSWORD, self.password),
(OutboundParams.SENDER, self.sender)]
try:
text = str(message.text)
# it's ascii
params.append((OutboundParams.MESSAGE, text))
except UnicodeEncodeError:
params.extend(UNICODE_PARAMS)
encoded = message.text.encode("utf_16_be").encode("hex").upper()
params.append((OutboundParams.MESSAGE, encoded))
try:
data = urlopen('%s?%s' % (OUTBOUND_URLBASE, urlencode(params)),
timeout=settings.SMS_GATEWAY_TIMEOUT).read()
except Exception:
data = None
create_billable_for_sms(message,
UnicelBackend.get_api_id(),
delay=delay,
response=data)
return data
def send(self, message, delay=True, *args, **kwargs):
"""
Send an outbound message using the Unicel API
"""
phone_number = clean_phone_number(message.phone_number).replace("+", "")
params = [(OutboundParams.DESTINATION, phone_number),
(OutboundParams.USERNAME, self.username),
(OutboundParams.PASSWORD, self.password),
(OutboundParams.SENDER, self.sender)]
try:
text = str(message.text)
# it's ascii
params.append((OutboundParams.MESSAGE, text))
except UnicodeEncodeError:
params.extend(UNICODE_PARAMS)
encoded = message.text.encode("utf_16_be").encode("hex").upper()
params.append((OutboundParams.MESSAGE, encoded))
try:
data = urlopen('%s?%s' % (OUTBOUND_URLBASE, urlencode(params))).read()
except Exception:
data = None
create_billable_for_sms(message, UnicelBackend.get_api_id(), delay=delay, response=data)
return data
def send(msg, delay=True, *args, **kwargs):
"""
Expected kwargs:
messaging_token
"""
phone_number = msg.phone_number
if phone_number[0] != "+":
phone_number = "+" + phone_number
try:
text = str(msg.text)
except UnicodeEncodeError:
text = msg.text.encode("utf-8")
params = urlencode({
"action" : "create"
,"token" : kwargs["messaging_token"]
,"numberToDial" : phone_number
,"msg" : text
,"_send_sms" : "true"
})
url = "https://api.tropo.com/1.0/sessions?%s" % params
response = urlopen(url).read()
msg.save()
create_billable_for_sms(msg, API_ID, delay=delay, response=response)
return response
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
def send(self, msg, delay=True, *args, **kwargs):
phone_number = clean_phone_number(msg.phone_number)
text = msg.text.encode("utf-8")
params = urlencode({
"action" : "create",
"token" : self.messaging_token,
"numberToDial" : phone_number,
"msg" : text,
"_send_sms" : "true",
})
url = "https://api.tropo.com/1.0/sessions?%s" % params
response = urlopen(url, timeout=settings.SMS_GATEWAY_TIMEOUT).read()
create_billable_for_sms(msg, TropoBackend.get_api_id(), delay=delay, response=response)
return response
def handle(self, *labels, **options):
db = SMSLog.get_db()
# active_domains = db.view(
# "sms/by_domain",
# reduce=True,
# group_level=1,
# ).all()
# active_domains = [d['key'][0] for d in active_domains]
active_domains = ['pathfinder']
startkey = lambda d: [d, "SMSLog", "2013-08-01"]
endkey = lambda d: [d, "SMSLog", "2013-10-15"]
for domain in active_domains:
data = db.view(
"sms/by_domain",
reduce=False,
startkey=startkey(domain),
endkey=endkey(domain),
).all()
sms_ids = [d['id'] for d in data]
for doc in iter_docs(db, sms_ids):
sms_log = SMSLog.wrap(doc)
if not sms_log.billed and sms_log.backend_api in [
'MACH',
# 'TROPO',
# 'UNICEL',
]:
# we're going to assume the SMS messages were sent successfully
# at the time they were actually sent
successful_responses = {
'MACH': "MACH RESPONSE +OK 01 message queued (dest=%s)" % sms_log.phone_number,
'TROPO': "<success>true</success>",
'UNICEL': "success",
}
print "Retroactively billing SMLog %s in domain %s" % (sms_log._id, sms_log.domain)
try:
create_billable_for_sms(
sms_log,
sms_log.backend_api,
delay=False,
response=successful_responses[sms_log.backend_api],
)
except Exception as e:
print "Retroactive bill was not successful due to error: %s" % e
logging.exception(e)
def send(self, msg, delay=True, *args, **kwargs):
params = {
"id" : self.account_id,
"pw" : self.password,
"snr" : self.sender_id,
"dnr" : msg.phone_number,
}
try:
text = msg.text.encode("iso-8859-1")
params["msg"] = text
except UnicodeEncodeError:
params["msg"] = msg.text.encode("utf-16-be").encode("hex")
params["encoding"] = "ucs"
url = "%s?%s" % (MACH_URL, urllib.urlencode(params))
resp = urllib2.urlopen(url, timeout=settings.SMS_GATEWAY_TIMEOUT).read()
create_billable_for_sms(msg, MachBackend.get_api_id(), delay=delay, response=resp)
return resp
def send(self, msg, delay=True, *args, **kwargs):
phone_number = clean_phone_number(msg.phone_number)
text = msg.text.encode("utf-8")
params = urlencode({
"action": "create",
"token": self.messaging_token,
"numberToDial": phone_number,
"msg": text,
"_send_sms": "true",
})
url = "https://api.tropo.com/1.0/sessions?%s" % params
response = urlopen(url, timeout=settings.SMS_GATEWAY_TIMEOUT).read()
create_billable_for_sms(msg,
TropoBackend.get_api_id(),
delay=delay,
response=response)
return response
def send(msg, delay=True, *args, **kwargs):
"""
Sends a message via mach's API
"""
outgoing_sms_text = clean_outgoing_sms_text(msg.text)
context = {
'message': outgoing_sms_text,
'phone_number': urllib.quote(msg.phone_number),
'sender_id': urllib.quote(kwargs.get("sender_id", DEFAULT_SENDER_ID)),
}
url = "%s?%s" % (settings.SMS_GATEWAY_URL, settings.SMS_GATEWAY_PARAMS % context)
# just opening the url is enough to send the message
# TODO, check response
resp = urllib2.urlopen(url).read()
msg.save()
create_billable_for_sms(msg, API_ID, delay=delay, response=resp)
return resp
def send(self, msg, delay=True, *args, **kwargs):
phone_number = clean_phone_number(msg.phone_number)
try:
text = msg.text.encode("iso-8859-1")
except UnicodeEncodeError:
text = msg.text.encode("utf-8")
params = urlencode(
{
"action": "create",
"token": self.messaging_token,
"numberToDial": phone_number,
"msg": text,
"_send_sms": "true",
}
)
url = "https://api.tropo.com/1.0/sessions?%s" % params
response = urlopen(url).read()
create_billable_for_sms(msg, TropoBackend.get_api_id(), delay=delay, response=response)
return response
def send(self, msg, delay=True, *args, **kwargs):
params = {
"id": self.account_id,
"pw": self.password,
"snr": self.sender_id,
"dnr": msg.phone_number,
}
try:
text = msg.text.encode("iso-8859-1")
params["msg"] = text
except UnicodeEncodeError:
params["msg"] = msg.text.encode("utf-16-be").encode("hex")
params["encoding"] = "ucs"
url = "%s?%s" % (MACH_URL, urllib.urlencode(params))
resp = urllib2.urlopen(url,
timeout=settings.SMS_GATEWAY_TIMEOUT).read()
create_billable_for_sms(msg,
MachBackend.get_api_id(),
delay=delay,
response=resp)
return resp
def send(msg, delay=True, *args, **kwargs):
"""
Sends a message via mach's API
"""
context = {
'phone_number': urllib.quote(msg.phone_number),
'sender_id': urllib.quote(kwargs.get("sender_id", DEFAULT_SENDER_ID)),
}
encoding_param = ""
try:
text = msg.text.encode("iso-8859-1")
context["message"] = clean_outgoing_sms_text(text)
except UnicodeEncodeError:
context["message"] = msg.text.encode("utf-16-be").encode("hex")
encoding_param = "&encoding=ucs"
url = "%s?%s%s" % (settings.SMS_GATEWAY_URL, settings.SMS_GATEWAY_PARAMS % context, encoding_param)
# just opening the url is enough to send the message
# TODO, check response
resp = urllib2.urlopen(url).read()
msg.save()
create_billable_for_sms(msg, API_ID, delay=delay, response=resp)
return resp
def process_incoming(msg, delay=True):
v = VerifiedNumber.by_phone(msg.phone_number, include_pending=True)
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()
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
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
