def dial_outbound():
try:
event = request.args.get('Event')
call_uuid = request.args.get('DialBLegUUID')
if event == "DialAnswer":
auth_id = "Your AUTH_ID"
auth_token = "Your AUTH_TOKEN"
p = plivo.RestAPI(auth_id, auth_token)
record_params = {
'call_uuid': call_uuid,
'callback_url':
"https://morning-ocean-4669.herokuapp.com/recording_callback/",
'callback_method': "GET"
}
response = p.record(record_params)
print str(response)
play_params = {
'call_uuid': call_uuid,
'urls': "https://s3.amazonaws.com/plivocloud/Trumpet.mp3"
}
response = p.play(play_params)
print str(response)
return Response(response, mimetype='text/plain')
else:
print "Invalid"
return Response("INVALID", mimetype='text/plain')
except Exception as e:
print '\n'.join(traceback.format_exc().splitlines())
def message_back():
if request.method == 'POST':
print request.form
from_num = request.form.get('From')
from_parameters = request.form.get('Text')
from_parameters = from_parameters.strip().split()
print from_parameters
person = {}
person['phone_num'] = long(from_num)
person['country_code'] = from_parameters[0]
person['pregancy_stage'] = int(from_parameters[1])
person['has_smartphone'] = False
person['language'] = 'english'
person['responsiveness'] = 5
add_person(person)
subscriber_msg = "You are now subscribed to the feed"
message_params = {
'src': plivo_number,
'dst': from_num,
'text': subscriber_msg,
}
p = plivo.RestAPI(PLIVO_AUTH_ID, PLIVO_AUTH_TOKEN)
res = p.send_message(message_params)
return str(res)
def validate_message(id):
'''fire the validation and thus fire the calls'''
print "Validating: ", id
db = create_engine(SQLALCHEMY_DATABASE_URI)
metadata = MetaData(db)
entries = Table('entries', metadata, autoload=True)
esel = entries.select()
data = esel.execute(request_id=id).first()
print "Got data:", data['from_number']
params = {
'from': 1000,
'to': data['from_number'],
'answer_url': URL + '/verify/' + id
}
print "Params are: ", params
# Do plivo magic
p = plivo.RestAPI(data['auth_id'], data['auth_token'])
resp = p.make_call(params)
print "Fired: ", resp
def send(self, channel, msg, text):
# url used for logs and exceptions
url = 'https://api.plivo.com/v1/Account/%s/Message/' % channel.config[Channel.CONFIG_PLIVO_AUTH_ID]
client = plivo.RestAPI(channel.config[Channel.CONFIG_PLIVO_AUTH_ID], channel.config[Channel.CONFIG_PLIVO_AUTH_TOKEN])
status_url = "https://" + settings.TEMBA_HOST + "%s" % reverse('handlers.plivo_handler',
args=['status', channel.uuid])
payload = {'src': channel.address.lstrip('+'),
'dst': msg.urn_path.lstrip('+'),
'text': text,
'url': status_url,
'method': 'POST'}
event = HttpEvent('POST', url, json.dumps(payload))
start = time.time()
try:
# TODO: Grab real request and response here
plivo_response_status, plivo_response = client.send_message(params=payload)
event.status_code = plivo_response_status
event.response_body = plivo_response
except Exception as e: # pragma: no cover
raise SendException(six.text_type(e), event=event, start=start)
if plivo_response_status != 200 and plivo_response_status != 201 and plivo_response_status != 202:
raise SendException("Got non-200 response [%d] from API" % plivo_response_status,
event=event, start=start)
external_id = plivo_response['message_uuid'][0]
Channel.success(channel, msg, WIRED, start, event=event, external_id=external_id)
def answer(token):
plivo_client = plivo.RestAPI(plivo_settings['auth_id'], plivo_settings['auth_token'])
req = json.loads(request.data)
logging.debug(req)
name = req['pusher']['name']
repo = req['repository']['name']
commit_msg = req['head_commit']['message']
try:
userrepo = UserRepo.query.filter_by(token = token).first()
logging.debug(userrepo)
if userrepo is None:
logging.debug('Invalid token')
return 'Invalid token: %s' % token
if userrepo.repo_name != repo:
logging.debug('Invalid hook')
return 'Invalid hook: %r' % req
app.message= '%s pushed a commit to %s, %s' % (name, repo, commit_msg)
params = {
'to': str(userrepo.user.mobile),
'from': str(userrepo.user.mobile),
'answer_url': 'http://%s/answer/plivo/' % request.headers['HOST'],
}
(status_code, response) = plivo_client.make_call(params)
logging.debug(response)
except Exception as e:
logging.debug(str(e))
return str('this should not be reachable')
def conf_callback():
if request.method == 'GET':
conf_name = request.args.get('ConferenceName')
event = request.args.get('Event')
elif request.method == 'POST':
conf_name = request.form.get('ConferenceName')
event = request.form.get('Event')
response = make_response('OK')
response.headers['Content-type'] = 'text/plain'
print "Conference Name : %s " % (conf_name)
# The recording starts when the user enters the conference room
if event == "ConferenceEnter":
auth_id = "Your AUTH_ID"
auth_token = "Your AUTH_TOKEN"
p = plivo.RestAPI(auth_id, auth_token)
params = {
'conference_name' : conf_name
}
response = p.record_conference(params)
print str(response)
return str(response)
else:
print "invalid"
return Response("INVALID", mimetype='text/plain')
def connect_plivo(info):
auth_id = "MANJI1ZGQYOWQ3NTU4MW"
auth_token = "NmU2YThiMmZiM2FlNDM1MDFkMTQ2NTAyMDJmNDdh"
p = plivo.RestAPI(auth_id, auth_token)
params = {
'to':
'12566655017', # The phone numer to which the call will be placed // Arsh: 16784670532
'from':
'11111111111', # The phone number to be used as the caller id
# answer_url is the URL invoked by Plivo when the outbound call is answered
# and contains instructions telling Plivo what to do with the call
'answer_url':
"https://text-to-plivo-speech.herokuapp.com/text-to-speech/" + info,
'answer_method':
"GET", # The method used to call the answer_url
# Example for asynchronous request
# callback_url is the URL to which the API response is sent.
#'callback_url' => "http://myvoiceapp.com/callback/",
#'callback_method' => "GET" # The method used to notify the callback_url.
}
# Make an outbound call and print the response
response = p.make_call(params)
print str(response)
return str(response)
def send_phone_code(request, id):
if request.method == 'GET':
if request.user.account.id != int(id):
raise PermissionDenied
account = get_object_or_404(Account, pk=id)
code = random.randint(1000, 9999)
if account.phone_verified == 1:
raise ValidationError(detail={'error': 'This email is already verified'})
sms_content = '''Thanks for using Vinna app.
Please verify your phone number.
Verification code: %d''' % code
plivo_instance = plivo.RestAPI(settings.PLIVO_AUTH_ID, settings.PLIVO_TOKEN)
account = get_object_or_404(Account, pk=id)
params = {
'src': settings.VERIFICATION_SENDER_PHONE,
'dst' : account.country.phone_country_code + account.phone,
'text' : sms_content,
'method' : 'POST'
}
response = plivo_instance.send_message(params)
if response[0] != 202:
raise ValidationError(detail={'error': response[1]})
account.phone_verified = code
account.save()
return Response({'detail': 'Code updated'}, status=status.HTTP_200_OK)
class SMS(ndb.Expando):
auth_id = "MAMTKWZGMYZDIWNJI3ZD"
auth_token = "MjUwNzUzYjc2MGNjMjNmMDdmNGY3YmEyMTA4YTE3"
smsURL = "https://api.plivo.com/v1/Account/MAMTKWZGMYZDIWNJI3ZD/Message/"
p = plivo.RestAPI(auth_id, auth_token)
params = {
'src': '27790471558', # Sender's phone number with country code
'dst' : '27790471559', # Receiver's phone Number with country code
'text' : u"Hello, this is plivo talking to you hello master?", # Your SMS Text Message - English
'url' : "https://api.plivo.com/v1/Account/MAMTKWZGMYZDIWNJI3ZD/Message/", # The URL to which with the status of the message is sent
'method' : 'POST' # The method used to call the url
}
def sendSMS(self,dst,text):
try:
destination = str(dst)
message = str(text)
message = message.strip()
if destination.isdigit() and (len(destination) >= 10) and not(message == None):
context = {'src': '27790471559', 'dst': destination , 'text': message, 'url': self.smsURL,'method':'post'}
response = self.p.send_message(context)
return response
else:
return None
except:
return None
def send_sms(phone_number, message):
"""
Send an SMS message to a given phone number
Args:
phone_number: E.164 format phone number to send message to without the
leading + sign
message: SMS text body
Returns:
None
"""
if (phone_number is not None) and (message is not None):
# phone number shouldn't have a + sign per plivo docs
phone_number = ''.join(c for c in phone_number if c.isalnum())
plivoAPI = plivo.RestAPI(settings.PLIVO_AUTH_ID,
settings.PLIVO_AUTH_TOKEN)
params = {
'src': settings.PLIVO_NUMBER,
'dst': phone_number,
'text': message,
'type': 'sms'
}
if settings.PLIVO_DEBUG:
# Dont bother wasting credits when just testing out
print params
else:
plivoAPI.send_message(params)
def trigger_send(num_list, message):
"""
Queues the messages.
Returns the success/fail status.
"""
auth_id = config.PLIVO_ID
auth_token = config.PLIVO_KEY
p = plivo.RestAPI(auth_id, auth_token)
params = {
'src': config.PLIVO_SRC, # Sender's phone number with country code
'dst': _parse_list(
num_list
), # Receivers' phone numbers with country code. The numbers are separated by "<" delimiter.
'text': message # Your SMS Text Message
}
# response = p.send_message(params)
if response[0] >= 200 and response[0] <= 299:
# 2XX Message. Probably ok.
return True
else:
print(response)
return False
def getAccDetails(self):
try:
p = plivo.RestAPI(self.auth_id, self.auth_token)
accDets = plivo.Account()
print("Account Details:{}".format(accDets))
except plivo.PlivoError as e:
print(e)
def find_phone(request):
if request.method == 'POST':
if not 'phone' in request.data:
raise ValidationError(detail={'error': 'Phone number is required'})
phone = request.data['phone']
account = None
try:
account = get_object_or_404(Account, phone=phone)
except:
pass
if account:
return Response(account.first_name, status=status.HTTP_200_OK)
else:
code = random.randint(1000, 9999)
sms_content = 'Vinna code: ' + str(code)
plivo_instance = plivo.RestAPI(settings.PLIVO_AUTH_ID, settings.PLIVO_TOKEN)
params = {
'src': settings.VERIFICATION_SENDER_PHONE,
'dst' : '1' + phone,
'text' : sms_content,
'method' : 'POST'
}
response = plivo_instance.send_message(params)
raise ValidationError(detail={code})
def run_live():
port = '8000'
print("Running ngrok ...")
ngrok = pexpect.spawn('ngrok', ['http', port])
ngrok.expect(r'Forwarding\s+(http://.*?\.ngrok\.io)')
print("Configuring plivo application ...")
message_url = urljoin(
ngrok.match.group(1).decode('ascii'), reverse('receive_sms'))
sms_client = plivo.RestAPI(settings.PLIVO_AUTH_ID,
settings.PLIVO_AUTH_TOKEN)
response_code, response_info = sms_client.modify_application({
'app_id':
settings.PLIVO_APPLICATION_ID,
'message_url':
message_url
})
if response_code == 202:
print("Plivo message endpoint changed to %s" % message_url)
else:
print("Unable to set Plivo message endpoint: %s" %
response_info['message'])
return
try:
local("python manage.py runserver 0.0.0.0:%s" % port)
finally:
ngrok.close()
def send_message_plivo(phone, body):
api = plivo.RestAPI(settings.PLIVO_AUTH_ID, settings.PLIVO_AUTH_TOKEN)
plivo_message = api.Message.send(src=settings.PLIVO_PHONE,
dst=str(phone.phone),
text=body,
url=settings.PLIVO_WEBHOOK_URL)
from .models import Message
message = Message(phone=phone, gateway=Message.PLIVO)
if plivo_message.status_code != 202:
logger.exception('Failed to send Plivo message.',
extra={
'phone': phone,
'body': body,
'plivo_message.status_code':
plivo_message.status_code,
'plivo_message.json_data': plivo_message.json_data
})
message.status = Message.FAILED
message.error = (
'Status code {status_code}, JSON data: \n{json_data}'.format(
status_code=plivo_message.status_code,
json_data=plivo_message.json_data))
message.save()
return message
# Split messages are not supported.
message.remote_uuid = plivo_message.json_data['message_uuid'][0]
message.save()
return message
def getResponse(self):
# Message Detail Record i.e. MDR has several attributes
p = plivo.RestAPI(self.auth_id, self.auth_token) # ??
try:
xml_response = plivo.XML.Response() # missing argument
print("Response:{}".format(xml_response))
except plivo.PlivoError as e:
print(e)
def process_control(self, data):
algobroker.Broker.process_control(self, data)
if data.get('cmd', None) == "auth":
self.auth_id = data['PLIVO_AUTH_ID']
self.auth_token = data['PLIVO_AUTH_TOKEN']
self.api = plivo.RestAPI(self.auth_id, self.auth_token)
self.src_number = data['src_number']
self.dst_number = data['dst_number']
def claim_number(self, user, phone_number, country, role):
auth_id = self.request.session.get(Channel.CONFIG_PLIVO_AUTH_ID, None)
auth_token = self.request.session.get(Channel.CONFIG_PLIVO_AUTH_TOKEN, None)
org = user.get_org()
plivo_uuid = generate_uuid()
app_name = "%s/%s" % (settings.TEMBA_HOST.lower(), plivo_uuid)
client = plivo.RestAPI(auth_id, auth_token)
message_url = "https://" + settings.TEMBA_HOST + "%s" % reverse('handlers.plivo_handler', args=['receive', plivo_uuid])
answer_url = "https://" + settings.AWS_BUCKET_DOMAIN + "/plivo_voice_unavailable.xml"
plivo_response_status, plivo_response = client.create_application(params=dict(app_name=app_name,
answer_url=answer_url,
message_url=message_url))
if plivo_response_status in [201, 200, 202]:
plivo_app_id = plivo_response['app_id']
else: # pragma: no cover
plivo_app_id = None
plivo_config = {Channel.CONFIG_PLIVO_AUTH_ID: auth_id,
Channel.CONFIG_PLIVO_AUTH_TOKEN: auth_token,
Channel.CONFIG_PLIVO_APP_ID: plivo_app_id}
plivo_number = phone_number.strip('+ ').replace(' ', '')
plivo_response_status, plivo_response = client.get_number(params=dict(number=plivo_number))
if plivo_response_status != 200:
plivo_response_status, plivo_response = client.buy_phone_number(params=dict(number=plivo_number))
if plivo_response_status != 201: # pragma: no cover
raise Exception(_("There was a problem claiming that number, please check the balance on your account."))
plivo_response_status, plivo_response = client.get_number(params=dict(number=plivo_number))
if plivo_response_status == 200:
plivo_response_status, plivo_response = client.modify_number(params=dict(number=plivo_number,
app_id=plivo_app_id))
if plivo_response_status != 202: # pragma: no cover
raise Exception(_("There was a problem updating that number, please try again."))
phone_number = '+' + plivo_number
phone = phonenumbers.format_number(phonenumbers.parse(phone_number, None),
phonenumbers.PhoneNumberFormat.NATIONAL)
channel = Channel.create(org, user, country, 'PL', name=phone, address=phone_number,
config=plivo_config, uuid=plivo_uuid)
analytics.track(user.username, 'temba.channel_claim_plivo', dict(number=phone_number))
return channel
def send_sms(to, text):
client = plivo.RestAPI(PLIVO_AUTH_ID, PLIVO_AUTH_TOKEN)
params = {
'src': SMS_SOURCE_NUMBER,
'text': text,
}
for number in to:
params['dst'] = number
message = client.send_message(params)
return True
def send_sms(to_number, text):
cc = phone_country(to_number)
src = {'US': '17077776191', 'CA': '13433441234'}.get(cc, '17077776191')
p = plivo.RestAPI(current_app.config['PLIVO_AUTH_ID'],
current_app.config['PLIVO_AUTH_TOKEN'])
params = {'src': src, 'dst': str(to_number), 'text': text}
res = p.send_message(params)
return '', 200
def alarm(number):
p = plivo.RestAPI(auth_id, auth_token)
params = {
'to': number,
'from': '16623829952',
'answer_url': "http://molson194.tk/answer.xml",
'answer_method': "GET"
}
response = p.make_call(params)
print str(response)
def send(self, to, msg, src=None):
try:
if not src:
src = self.src
client = plivo.RestAPI(self.auth_id, self.auth_token)
message = client.Message.send(src=src, dst=to, text=msg[:160])
return message
except:
pass
return False
def plivomisscall(self, source, destination):
self.call_params['from'] = source
self.call_params['answer_method'] = 'POST'
self.call_params['answer_url'] = self.answer_url
self.call_params['to'] = destination
self.call_params['hangup_on_ring'] = PlivoInfo.plivo_hang_onring
triger_call = plivo.RestAPI(self.auth_id, self.auth_token)
call_result = triger_call.make_call(self.call_params)
print call_result
def comMsg(self):
p = plivo.RestAPI(self.auth_id, self.auth_token)
try:
response = p.Message.create(
src='+13238318440',
dst='+13252210570',
text='Test Message',
)
print(response)
except plivo.PlivoError as e:
print(e)
def outcall():
p=plivo.RestAPI(auth_id, auth_token)
call_params={
'to':'ph',
'from':'xxxxxxxxxx',
'answer_url':'https://www.dropbox.com/s/n76obusmwo64ttr/hangup.xml'
}
response = p.make_call(call_params)
# if response['message']!='call fired':
# return 'call not made'
# else:
return 'call in progress'
def get_valid_client(self):
auth_id = self.request.session.get(Channel.CONFIG_PLIVO_AUTH_ID, None)
auth_token = self.request.session.get(Channel.CONFIG_PLIVO_AUTH_TOKEN, None)
try:
client = plivo.RestAPI(auth_id, auth_token)
validation_response = client.get_account()
if validation_response[0] != 200:
client = None
except plivo.PlivoError: # pragma: needs cover
client = None
return client
def send_sms(text, phone_number):
try:
p = plivo.RestAPI('MAMZRJZMMWM2RLNTG2MD',
'ZWZlZTA2YTZkZjEzNmJjZmFmYjQyYTc3NGY0NDU4')
params = {
'src': 'TOLL-ME',
'dst': '+91' + str(phone_number),
'text': "Your OTP for Verification is: " + text
}
#print(params)
p.send_message(params)
except plivo.exceptions.PlivoRestError as e:
print(e)
def call(number, message):
auth_id = config['AUTH_ID']
auth_token = config['AUTH_TOKEN']
p = plivo.RestAPI(auth_id, auth_token)
params = {
'from': '1212121212',
'to': number,
'answer_url': config['BASE_URL'] + '/answer?message=' + message,
'answer_method': "GET",
}
response = p.make_call(params)
return response
def send_plivo_message(to_number, body):
p = plivo.RestAPI('MAZWU5ZWVKNMU4MZG1N2',
'YWMzMzk5NmIzNzc2MTAyZDI4ZTIwYzYzMWZhOTM0')
flag = content_tiny_url(body)
params = {
'src': '+919686798312', # Caller Id
'dst': to_number, # User Number to Call
'text': flag,
'type': "sms",
}
response = p.send_message(params)
return response
def send_text(dict_of_recipients, auth_id, token):
"""Sends text messages, logging when the text was not sent."""
p = plivo.RestAPI(auth_id, token)
for name, number in dict_of_recipients.items():
print("sending text to {}".format(name))
params = {
'src': plivo_number,
'dst' : number,
'text' : "Hi {}, just a reminder that you have water changes this week that you have either not done or not signed off on. Thanks!".format(name),
'method' : 'POST'
}
response = p.send_message(params)
