def generate_text(number, message): # create an instance of the API class api_instance = Telstra_Messaging.AuthenticationApi() client_id = "Agl2rsjQ0fbLC1xqPGDNve2Oianci7wK" # str | client_secret = "eWJoCzsYcTk2ITRl" # str | grant_type = 'client_credentials' # str | (default to client_credentials) try: # Generate OAuth2 token api_response = api_instance.auth_token(client_id, client_secret, grant_type) access_token = api_response.__getattribute__('access_token') configuration = Telstra_Messaging.Configuration() configuration.access_token = access_token api_instance = Telstra_Messaging.MessagingApi( Telstra_Messaging.ApiClient(configuration)) payload = {"to": number, "validity": "60", "body": message} try: # Send SMS api_response = api_instance.send_sms(payload) except ApiException as e: print("Exception when calling MessagingApi->send_sms: %s\n" % e) except ApiException as e: print("Exception when calling AuthenticationApi->auth_token: %s\n" % e) return "text sent"
def get_token(): global TELSTRA_ACCESS_TOKEN, TELSTRA_ACCESS_TOKEN_EXPIRY access_token = TELSTRA_ACCESS_TOKEN if TELSTRA_ACCESS_TOKEN_EXPIRY > datetime.now( ) else None if access_token: return access_token configuration = Telstra_Messaging.Configuration() api_instance = Telstra_Messaging.AuthenticationApi( Telstra_Messaging.ApiClient(configuration)) client_id = configs.TELSTRA_CLIENT_KEY client_secret = configs.TELSTRA_CLIENT_SECRET grant_type = 'client_credentials' try: # Generate OAuth2 token api_response = api_instance.auth_token(client_id, client_secret, grant_type) access_token = api_response.access_token expires_in = int(api_response.expires_in ) if api_response.expires_in.isdigit() else 3599 TELSTRA_ACCESS_TOKEN = access_token TELSTRA_ACCESS_TOKEN_EXPIRY = datetime.now() + timedelta( seconds=expires_in) return access_token except ApiException as e: log.error( "Exception when calling AuthenticationApi->auth_token: %s\n" % e) return None
def get_token(): access_token = r.get(TELSTRA_SMS_ACCESS_TOKEN) if access_token: return access_token configuration = Telstra_Messaging.Configuration() api_instance = Telstra_Messaging.AuthenticationApi( Telstra_Messaging.ApiClient(configuration)) client_id = settings.TELSTRA_CLIENT_KEY client_secret = settings.TELSTRA_CLIENT_SECRET grant_type = 'client_credentials' try: # Generate OAuth2 token api_response = api_instance.auth_token(client_id, client_secret, grant_type) access_token = api_response.access_token expires_in = int(api_response.expires_in ) if api_response.expires_in.isdigit() else 3599 r.setex(TELSTRA_SMS_ACCESS_TOKEN, expires_in, access_token) return access_token except ApiException as e: log.error( "Exception when calling AuthenticationApi->auth_token: %s\n" % e) return None
def register_free_trial_bnum(): configuration = Telstra_Messaging.Configuration() configuration.access_token = get_token() api_client = Telstra_Messaging.ApiClient(configuration) url = 'https://tapi.telstra.com/v2/messages/freetrial/bnum' headers = {'Accept': 'application/json', 'Content-Type': 'application/json', 'User-Agent': 'OpenAPI-Generator/1.0.7/python', 'Authorization': 'Bearer JzW3OGXwQMhlXXsRNosuVbG7QHLR'} body = {"bnum": [ "+61413725868", ]} response = api_client.rest_client.POST(url, query_params=[], headers=headers, post_params=[], _preload_content=True, _request_timeout=None, body=body) data = json.loads(response.data) status = response.status headers = response.getheaders() return data
def send_au_sms(to, body, app_name=None): counter = r.get(TELSTRA_SMS_MONTHLY_COUNTER) or 0 counter = int(counter) if not counter < TELSTRA_MONTHLY_FREE_LIMIT: log.info('[SMS] Telstra SMS reach 1000 free limitation.') return False, 'Telstra SMS reach 1000 free limitation.' to = validate_au_mobile(to) if not to: return False, 'INVALID_PHONE_NUMBER' body = str(body) if not body: return False, 'EMPTY_CONTENT' # Configure OAuth2 access token for authorization: auth configuration = Telstra_Messaging.Configuration() configuration.access_token = get_token() from_number = get_from_number() # api_instance = Telstra_Messaging.ProvisioningApi(Telstra_Messaging.ApiClient(configuration)) # provision_number_request = Telstra_Messaging.ProvisionNumberRequest() # ProvisionNumberRequest | A JSON payload containing the required attributes api_instance = Telstra_Messaging.MessagingApi( Telstra_Messaging.ApiClient(configuration)) send_sms_request = Telstra_Messaging.SendSMSRequest(to, body, from_number) try: # {'country': [{u'AUS': 1}], # 'message_type': 'SMS', # 'messages': [{'delivery_status': 'MessageWaiting', # 'message_id': 'd872ad3b000801660000000000462650037a0801-1261413725868', # 'message_status_url': 'https://tapi.telstra.com/v2/messages/sms/d872ad3b000801660000000000462650037a0801-1261413725868/status', # 'to': '+61413725868'}], # 'number_segments': 1} api_response = api_instance.send_sms(send_sms_request) success = api_response.messages[0].delivery_status == 'MessageWaiting' if connection.schema_name.startswith(Tenant.SCHEMA_NAME_PREFIX): sms = Sms(app_name=app_name, send_to=to, content=body, success=success, template_code=api_response.messages[0].delivery_status, remark=api_response.messages[0].message_status_url, biz_id=api_response.messages[0].delivery_status) sms.save() if success: counter = r.get(TELSTRA_SMS_MONTHLY_COUNTER) or 0 counter = int(counter) counter += 1 r.set(TELSTRA_SMS_MONTHLY_COUNTER, counter) if counter == TELSTRA_MONTHLY_FREE_LIMIT - 1: send_to_admin('[Warning] Telstra sms meet monthly limitation.') r.set(TELSTRA_SMS_MONTHLY_COUNTER, counter + 1) return True, 'MessageWaiting' except ApiException as e: log.error("Exception when calling MessagingApi->send_sms: %s\n" % e) return False, str(e)
def auth(self): grant_type = 'client_credentials' api_instance = telstra.AuthenticationApi() resp = api_instance.auth_token(self._client_id, self._client_secret, grant_type) conf = telstra.Configuration() conf.access_token = resp.access_token return conf
def sendSMS(self, recipient, message): 'Sends a SMS to the given recipient with the given message.' self.__checkAuthToken() api_instance_Messaging = Telstra_Messaging.MessagingApi( Telstra_Messaging.ApiClient(self.configuration)) payload = Telstra_Messaging.SendSMSRequest(recipient, message) try: api_response = api_instance_Messaging.send_sms(payload) pprint(api_response) except ApiException as e: print("Exception when calling MessagingApi->send_sms: %s\n" % e)
def authenticate_client(self): api_instance = Telstra_Messaging.AuthenticationApi( Telstra_Messaging.ApiClient(self.configuration)) try: # Generate OAuth2 token self.api_response = api_instance.auth_token( self.client_id, self.client_secret, self.grant_type) except ApiException as e: print( "Exception when calling AuthenticationApi->auth_token: %s\n" % e)
def send_au_sms(mobile_number, message, from_app=None): counter = redis_counter.get_telstra_monthly_counter() counter = int(counter) if not counter < TELSTRA_MONTHLY_FREE_LIMIT: logger.info('[SMS] Telstra SMS reach 1000 free limitation.') return False, 'Telstra SMS reach 1000 free limitation.' mobile_number = validate_au_mobile(mobile_number) if not mobile_number: return False, 'INVALID_PHONE_NUMBER' message = str(message) if not message: return False, 'EMPTY_CONTENT' # Configure OAuth2 access token for authorization: auth configuration = Telstra_Messaging.Configuration() configuration.access_token = get_token() from_number = _get_from_number() # api_instance = Telstra_Messaging.ProvisioningApi(Telstra_Messaging.ApiClient(configuration)) # provision_number_request = Telstra_Messaging.ProvisionNumberRequest() # ProvisionNumberRequest | A JSON payload containing the required attributes api_instance = Telstra_Messaging.MessagingApi( Telstra_Messaging.ApiClient(configuration)) send_sms_request = Telstra_Messaging.SendSMSRequest( mobile_number, message, from_number) try: # {'country': [{u'AUS': 1}], # 'message_type': 'SMS', # 'messages': [{'delivery_status': 'MessageWaiting', # 'message_id': 'd872ad3b000801660000000000462650037a0801-1261413725868', # 'message_status_url': 'https://tapi.telstra.com/v2/messages/sms/d872ad3b000801660000000000462650037a0801-1261413725868/status', # 'to': '+61413725868'}], # 'number_segments': 1} api_response = api_instance.send_sms(send_sms_request) success = api_response.messages[0].delivery_status == 'MessageWaiting' if success: counter = redis_counter.get_telstra_monthly_counter() counter = int(counter) counter += 1 redis_counter.set_telstra_monthly_counter(counter) if counter == TELSTRA_MONTHLY_FREE_LIMIT - 1: send_to_admin('[Warning] Telstra sms meet monthly limitation.') redis_counter.set_telstra_monthly_counter(counter + 1) return True, 'MessageWaiting' except ApiException as e: logger.error("Exception when calling MessagingApi->send_sms: %s\n" % e) return False, str(e)
def send_sms(self, msg_to, msg_body): api_instance = Telstra_Messaging.MessagingApi( Telstra_Messaging.ApiClient(self.configuration)) send_sms_request = Telstra_Messaging.SendSMSRequest(to=msg_to, body=msg_body) try: # Send SMS api_response = api_instance.send_sms(send_sms_request) # pprint(api_response) return True except ApiException as e: print("Exception when calling MessagingApi->send_sms: %s\n" % e)
def provision_client(self): api_instance = Telstra_Messaging.ProvisioningApi( Telstra_Messaging.ApiClient(self.configuration)) provision_number_request = Telstra_Messaging.ProvisionNumberRequest() try: # Create Subscription api_response = api_instance.create_subscription( provision_number_request) api_response = api_instance.get_subscription() except ApiException as e: print( "Exception when calling ProvisioningApi->create_subscription: %s\n" % e)
def get_from_number(): destination_address = r.get(TELSTRA_SMS_DESTINATION_ADDRESS) if destination_address: return destination_address configuration = Telstra_Messaging.Configuration() configuration.access_token = get_token() api_instance = Telstra_Messaging.ProvisioningApi(Telstra_Messaging.ApiClient(configuration)) provision_number_request = Telstra_Messaging.ProvisionNumberRequest() # ProvisionNumberRequest | A JSON payload containing the required attributes api_response = api_instance.create_subscription(provision_number_request) destination_address = api_response.destination_address expiry_timestamp = int(api_response.expiry_date / 1000) expires_in = expiry_timestamp - int(time.mktime(datetime.datetime.now().timetuple())) r.setex(TELSTRA_SMS_DESTINATION_ADDRESS, expires_in, destination_address) return destination_address
def send_sms(self, to, content, reference, sender=None): telstra_api = telstra.MessagingApi(self._client) notify_url = f"{self.notify_host}/notifications/sms/telstra/{reference}" if self.notify_host else None payload = telstra.SendSMSRequest(to=to, body=content, _from=sender if sender else None, notify_url=notify_url) # Avoid circular imports by importing this file later. from app.models import ( NOTIFICATION_SENDING, NOTIFICATION_PERMANENT_FAILURE, ) try: resp = telstra_api.send_sms(payload) message = resp.messages[0] self.logger.info( f"Telstra send SMS request for {reference} succeeded: {message.message_id}" ) return message.message_id, NOTIFICATION_SENDING except telstra.rest.ApiException as e: try: messages = json.loads(e.body)["messages"] if e.status == 400 and len(messages) > 0 and messages[0][ "code"] == "TO-MSISDN-NOT-VALID" and messages[0][ "deliveryStatus"] == "DeliveryImpossible": self.logger.info( f"Telstra send SMS request for {reference} failed with API exception, status: {e.status}, reason: {e.reason}, message code: {messages[0]['code']}, message delivery status: {messages[0]['deliveryStatus']}" ) return None, NOTIFICATION_PERMANENT_FAILURE except ValueError: pass self.logger.error( f"Telstra send SMS request for {reference} failed with API exception" ) raise e except Exception as e: self.logger.error( f"Telstra send SMS request for {reference} failed") raise e
def generateAuthToken(self): 'Uses the Telstra messaging API client credientals to get an OAuth 2.0 token.' api_instance_Auth = Telstra_Messaging.AuthenticationApi() try: self.authToken = api_instance_Auth.auth_token( self.client_id, self.client_secret, self.grant_type) self.authTokenExpiry = datetime.now() + timedelta(seconds=3598) pprint(self.authToken) except ApiException as e: print( "Exception when calling AuthenticationApi->auth_token: %s\n" % e) self.configuration = Telstra_Messaging.Configuration() self.configuration.access_token = self.authToken.access_token self.provisionInstance = Telstra_Messaging.ProvisioningApi( Telstra_Messaging.ApiClient(self.configuration))
def deleteSubscription(self): 'Deletes the subscription, ie releases the mobile number in use.' self.__checkAuthToken() body = Telstra_Messaging.DeleteNumberRequest() try: self.provisionInstance.delete_subscription(body) except ApiException as e: print( "Exception when calling ProvisioningApi->delete_subscription: %s\n" % e)
def createSubscription(self, length=None): 'Creates a subscription with the Telstra API, ie gets a mobile number to use. length defines the number of days to create the subscription for, no value will default to API default.' self.__checkAuthToken() body = Telstra_Messaging.ProvisionNumberRequest(length) try: api_response = self.provisionInstance.create_subscription(body) pprint(api_response) except ApiException as e: print( "Exception when calling ProvisioningApi->create_subscription: %s\n" % e)
def send_sms(self, to, content, reference, sender=None): telstra_api = telstra.MessagingApi(self._client) notify_host = self._callback_notify_url_host notify_url = f"{notify_host}/notifications/sms/telstra/{reference}" if notify_host else None payload = telstra.SendSMSRequest(to=to, body=content, _from=sender if sender else None, notify_url=notify_url) try: resp = telstra_api.send_sms(payload) message = resp.messages[0] self.logger.info( f"Telstra send SMS request for {reference} succeeded: {message.message_id}" ) except Exception as e: self.logger.error( f"Telstra send SMS request for {reference} failed") raise e
def send_sms(self, to, content, reference, sender=None): conf = self.auth() api_instance = Telstra_Messaging.MessagingApi(Telstra_Messaging.ApiClient(conf)) payload = Telstra_Messaging.SendSMSRequest( to=to, body=content, notify_url="{}/notifications/sms/telstra/{}".format(self._callback_notify_url_host, reference) ) start_time = monotonic() try: resp = api_instance.send_sms(payload) message = resp.messages[0] self.logger.info("Telstra send SMS request for {} succeeded: {}".format(reference, message.message_id)) except Exception as e: self.logger.error("Telstra send SMS request for {} failed".format(reference)) raise e finally: elapsed_time = monotonic() - start_time self.logger.info("Telstra send SMS request for {} finished in {}".format(reference, elapsed_time))
def auth(self): grant_type = 'client_credentials' api_instance = Telstra_Messaging.AuthenticationApi() start_time = monotonic() try: resp = api_instance.auth_token(self._client_id, self._client_secret, grant_type) self.logger.info("Telstra auth request succeeded") conf = Telstra_Messaging.Configuration() conf.access_token = resp.access_token return conf except Exception as e: self.logger.error("Telstra auth request failed") raise e finally: elapsed_time = monotonic() - start_time self.logger.info("Telstra auth request finished in {}".format(elapsed_time))
def get_from_number(): global TELSTRA_DESTINATION_ADDRESS, TELSTRA_DESTINATION_ADDRESS_EXPIRY destination_address = TELSTRA_DESTINATION_ADDRESS if TELSTRA_DESTINATION_ADDRESS_EXPIRY > datetime.now( ) else None if destination_address: return destination_address configuration = Telstra_Messaging.Configuration() configuration.access_token = get_token() api_instance = Telstra_Messaging.ProvisioningApi( Telstra_Messaging.ApiClient(configuration)) provision_number_request = Telstra_Messaging.ProvisionNumberRequest( ) # ProvisionNumberRequest | A JSON payload containing the required attributes api_response = api_instance.create_subscription(provision_number_request) destination_address = api_response.destination_address expiry_timestamp = int(api_response.expiry_date / 1000) expires_in = expiry_timestamp - int(time.mktime( datetime.now().timetuple())) TELSTRA_DESTINATION_ADDRESS = destination_address TELSTRA_DESTINATION_ADDRESS_EXPIRY = datetime.now() + timedelta( seconds=expires_in) return destination_address
def __init__(self): self.configuration = Telstra_Messaging.Configuration() self.configuration.access_token = credentials.ACCESS_TOKEN
from __future__ import print_function import time import Telstra_Messaging from Telstra_Messaging.rest import ApiException from pprint import pprint # Defining host is optional and default to https://tapi.telstra.com/v2 api_instance = Telstra_Messaging.AuthenticationApi( Telstra_Messaging.ApiClient()) client_id = 'Mr0NZxs2KsXcbqXJOgX1PRMtP4zkkgwG' # str | client_secret = 'qy7JjW8g98397oAM' # str | grant_type = 'client_credentials' # str | (default to 'client_credentials') scope = 'scope_example' # str | NSMS (optional) try: # Generate OAuth2 token api_response = api_instance.auth_token(client_id, client_secret, grant_type, scope=scope) pprint(api_response) except ApiException as e: print("Exception when calling AuthenticationApi->auth_token: %s\n" % e)
def get_message_status(self, message_id): telstra_api = telstra.MessagingApi(self._client) return telstra_api.get_sms_status(message_id=message_id)
def provision_subscription(self): # maximum subscription is 5 years, 1825 days telstra_api = telstra.ProvisioningApi(self._client) req = telstra.ProvisionNumberRequest(active_days=1825) telstra_api.create_subscription(req)
def _client(self): return telstra.ApiClient(self.auth)