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