def call():
p.pprint(request.form)
response = VoiceResponse()
dial = Dial(callerId=twilio_number)
if 'To' in request.form and request.form['To'] != twilio_number:
print('outbound call')
dial.number(request.form['To'])
else:
print('incoming call')
caller = request.form['Caller']
dial = Dial(callerId=caller)
dial.client(twilio_number)
return str(response.append(dial))
def call(resp):
dial = Dial()
numbers = parse_NUMBERS(secret)
for number in numbers:
dial.number(number)
resp.append(dial)
def inbound_call():
response = VoiceResponse()
with Dial() as dial:
if request.values.get('From') == Moderator:
global agent_sid
agent_sid = request.values.get('CallSid')
print(agent_sid + ' is the agent sid')
dial.conference(
'AgentConference',
status_callback="/statuscallback",
status_callback_event="start end join leave mute hold")
else:
global customer_sid
customer_sid = request.values.get('CallSid')
print(customer_sid + ' is the customer sid')
dial.conference(
'AgentConference',
wait_url="/hold_message",
end_conference_on_exit=True,
status_callback="/statuscallback",
status_callback_event="start end join leave mute hold")
response.append(dial)
return str(response)
def make_outbound_call():
phone_number = request.form['Digits']
response = VoiceResponse()
dial = Dial(record=True, recording_status_callback='/recording/callback', recording_status_callback_event='completed')
dial.number(f"+{phone_number}", url='/seek/consent')
response.append(dial)
return str(response)
def call():
"""Returns TwiML instructions to Twilio's POST requests"""
response = VoiceResponse()
number = ""
zipCode = ""
dict = request.form
for value in dict:
if dict[value].startswith('number'):
number = dict[value].split(":")[-1]
if dict[value].startswith('zipCode'):
zipCode = dict[value].split(":")[-1]
phone_number = number # or default_client
zip_code = zipCode
print(phone_number)
print(zip_code)
# undecoded_phone = number
# base64_bytes = undecoded_phone.encode('ascii')
# message_bytes = base64.b64decode(base64_bytes)
# phone_number = str(decrypt(message_bytes, FERNET_KEY)).replace("b'","").replace("'","")
dial = Dial(callerId=NUMBERS_OUTBOUND)
try:
dial.number(numberVerify(zip_code, phone_number)['number'])
except:
dial.number(NUMBERS_OUTBOUND)
return str(response.append(dial))
def conference(request,
name,
muted=None,
beep=None,
start_conference_on_enter=None,
end_conference_on_exit=None,
wait_url=None,
wait_method='POST',
max_participants=None):
"""
See: http://www.twilio.com/docs/api/twiml/conference.
Usage::
# urls.py
urlpatterns = patterns('',
# ...
url(r'^conference/(?P<name>\w+)/$', 'django_twilio.views.conference',
{'max_participants': 10}),
# ...
)
"""
r = VoiceResponse()
dial = Dial()
dial.conference(
name=name,
muted=muted,
beep=beep,
startConferenceOnEnter=start_conference_on_enter,
endConferenceOnExit=end_conference_on_exit,
waitUrl=wait_url,
waitMethod=wait_method,
)
r.append(dial)
return r
def conference_call(request):
response = VoiceResponse()
room_name = request.POST['roomName']
dial = Dial()
dial.conference(room_name)
response.append(dial)
return HttpResponse(response.to_xml(), content_type='text/xml')
def incoming_call():
response = VoiceResponse()
dial = Dial()
incoming_number = request.values.get('From')
msg = f'Incoming call from {incoming_number}'
print(msg)
msg_attachments = [{
'color': 'danger',
'title': 'Incoming Call',
'fallback': msg,
'text': f'From *{incoming_number}*',
"mrkdwn_in": ["text", "pretext"],
}]
send_slack_message(f'<!channel>', msg_attachments)
status_url = url_for('call_status',
_external=True,
_scheme=get_http_scheme())
for number in get_hotline_numbers():
dial.number(
number,
status_callback_event='initiated ringing answered completed',
status_callback_method='POST',
status_callback=status_url,
)
response.append(dial)
return Response(str(response), 200, mimetype="application/xml")
def monitor():
account_sid = os.environ['TWILIO_ACCOUNT_SID']
auth_token = os.environ['AUTH_TOKEN']
sync_service_sid = os.environ['TWILIO_SYNC_SERVICE_SID']
client = Client(account_sid, auth_token)
global manager_sid
manager_sid = request.values.get('CallSid')
print(manager_sid + ' is the manager_sid')
new_data = {'manager_sid': manager_sid}
document = client.sync \
.services(sync_service_sid) \
.documents("AgentData") \
.update(data=new_data)
response = VoiceResponse()
dial = Dial()
dial.conference('AgentConference',
muted=True,
beep=False,
status_callback="/statuscallback",
status_callback_event="start end join leave mute hold")
response.append(dial)
return str(response)
def voice_four(request):
"""
Play voice 4 and do actions accordingly
"""
call_sid = None
choice = None
call_from = None
if request.method == 'POST':
call_sid = request.POST.get('CallSid', None)
choice = request.POST.get('Digits', None)
call_from = request.POST.get('From', None)
if request.method == 'GET':
call_sid = request.GET.get('CallSid', None)
choice = request.GET.get('Digits', None)
call_from = request.GET.get('From', None)
twiml = VoiceResponse()
if choice:
call_detail = CallDetail.objects.get(call_sid=call_sid)
call_detail.went_conference = True
call_detail.save()
if int(choice) == 1:
client.calls.create(to=num_sendCallTo, from_=num_sendCallTo, url=BASE_URL + '/Conference/' + call_sid,
status_callback=BASE_URL+'/ConferenceStatus/' + call_sid,
status_callback_method='POST', status_callback_event=["completed", "no-answer", "busy",
"failed"])
dial = Dial()
dial.conference(call_sid, wait_url='http://roelofvandijk.com/mp33/IVR/CallingInformation.mp3',
status_callback=BASE_URL+'/AddDrop?CallSid=' + call_sid + '&From='+call_from,
status_callback_method='POST', status_callback_event=['start', 'join', 'end'],
end_conference_on_exit=True, max_participants=2, start_conference_on_enter=True)
twiml.append(dial)
return HttpResponse(str(twiml))
twiml.hangup()
return HttpResponse(str(twiml))
return HttpResponse(str(twiml))
def gatherDigits(To, digit):
# If they pressed a correct option
group = get_group_by_did(To)
try:
if group and digit in [1, 2, 3, 4]:
mp3 = get_selected_language_mp3(group, digit)
conference_name = get_conference_name(group, digit)
# Build TWIML
response = VoiceResponse()
play = Play(mp3)
response.append(play)
dial = Dial()
dial.conference(muted=True,
beep=False,
end_conference_on_exit=False,
start_conference_on_enter=False,
max_participants=250,
trim="do-not-trim",
wait_url="/conference/onHold",
wait_method="GET",
name=conference_name)
response.append(dial)
return str(response)
except KeyError:
pass
response = VoiceResponse()
response.say("That is not a valid option")
# this should take you back to the first URL and function initialCall
response.redirect("/conference/join", method="GET")
return str(response)
def voice_reply():
response = VoiceResponse()
dial = Dial()
dial.conference('NYU')
response.append(dial)
return str(response)
def generate_connect_conference(call_sid, wait_url, start_on_enter, end_on_exit):
twiml_response = VoiceResponse()
dial = Dial()
dial.conference(call_sid,
start_conference_on_enter=start_on_enter,
end_conference_on_exit=end_on_exit,
wait_url=wait_url)
return str(twiml_response.append(dial))
def transferToManager():
# create TwiML that dials manager to customer conference as a participant
response = VoiceResponse()
dial = Dial()
dial.conference(request.values.get('conference'))
response.append(dial)
return Response(str(response), mimetype='text/xml')
def outbound(request):
if request.method == "POST":
response = VoiceResponse()
dial = Dial()
dial.number(getattr(settings, 'TO_BE_CONNECTED_TO'))
response.say("This is your new Copyfighters overlords.", voice='alice')
response.append(dial)
return HttpResponse(response)
return HttpResponseRedirect('/')
def conf_handle():
resp = VoiceResponse()
dial = Dial()
dial.conference("TEST", wait_url="/call-agent",
status="end",
end_conference_on_exit=True,
status_callback="/pop-first")
resp.append(dial)
return str(resp)
def auto_call():
# Get Emergency Service for location
# Dial number (Would be emergency service)
response = VoiceResponse()
dial = Dial()
dial.number('470-705-7212')
response.append(dial)
print(response)
# Get pickup status
response = VoiceResponse()
response.dial('415-123-4567', action='/handleDialCallStatus', method='GET')
response.say('I am unreachable')
# Twilio will submit a request to the action URL with the parameter 'DialCallStatus'.
# If nobody picks up, 'DialCallStatus' will be 'no-answer'.
# If the line is busy, 'DialCallStatus' will be 'busy'.
# If the called party picks up, 'DialCallStatus' will be 'completed'.
# If a conference is successfully dialed, 'DialCallStatus' will be 'answered'.
# If an invalid phone number was provided, 'DialCallStatus' will be 'failed'.
print(response)
# Automated Voice Intro = "(person's name)"
# Get information from Smart911Connect Account
# http://www.smart911connect.com/get-access/
# Development Block :(
# no free APIs that send medical info to Emergency Services, however they all return JSON
# Use Mongoose, JSON -> DB -> JSON
# Get information as JSON - Python NamedTuple -> String
# Feed into IBM Watson
import json
from watson_developer_cloud import DialogV1 as Dialog
dialog = Dialog(username='******', password='******')
dialog_id = 'YOUR_DIALOGID'
conversation = dialog.conversation(dialog_id)
client_id = conversation['client_id']
print dialog.update_profile(dialog_id=dialog_id, client_id=client_id,
name_values={"name_values": [{"name": "Product_Name", "value": "Sunglasses"}]})
print dialog.update_profile(dialog_id=dialog_id, client_id=client_id,
name_values=[{"name": "Product_Name", "value": "Sunglasses"}])
# Operator Interface with Twilio
return
def routedDialer(*args, **kwargs):
sipFrom = numberFromSip.match(kwargs['caller_id'])
if sipFrom and sipFrom.group('domain') in domains:
if sipFrom.group('user') in users:
kwargs['caller_id'] = users[sipFrom.group('user')]
elif sipFrom.group('number') in numbers:
kwargs['caller_id'] = sipFrom.group('number')
elif sipFrom:
del kwargs['caller_id']
return Dial(*args, **kwargs)
def make_dialout_response(self,
*,
sim: str = None,
to: str = None,
from_: str = None) -> TwiML:
"""Dial a number."""
response = VoiceResponse()
if from_:
dial = Dial(caller_id=f'+{from_}')
else:
dial = Dial()
if sim:
dial.sim(sim)
elif to:
dial.number(to)
else:
raise Exception("dialout response did not get anything to dial")
response.append(dial)
return str(response)
def handle_start_conference(from_phone, target_phone):
print("Starting conference")
response = VoiceResponse()
call_into_conference(target_phone)
dial = Dial()
conference_name = "{0}-{1}".format(from_phone, target_phone)
conferences_by_target["+" + target_phone] = conference_name
dial.conference(conference_name, start_conference_on_enter=True, end_conference_on_exit=True)
response.append(dial)
return str(response)
def dial_phone(self, outbound_dial):
# Creates call to user_number then dials outbound_dial
call = self.client.calls.create(
url=self.twiml_file,
to=self.config_save.get_user_number(),
from_=self.config_save.get_twilio_number())
response = VoiceResponse()
dial = Dial(url='xml/callinfo.xml')
dial.number(outbound_dial)
response.append(dial)
def test_sim(self):
d = Dial()
d.sim('123123123')
r = VoiceResponse()
r.append(d)
assert_equal(
self.strip(r),
'<?xml version="1.0" encoding="UTF-8"?><Response><Dial><Sim>123123123</Sim></Dial></Response>'
)
def test_queue(self):
d = Dial()
d.queue('TestQueueAttribute', url='', method='GET')
r = VoiceResponse()
r.append(d)
assert_equal(
self.strip(r),
'<?xml version="1.0" encoding="UTF-8"?><Response><Dial><Queue method="GET" url="">TestQueueAttribute</Queue></Dial></Response>'
)
def perform_call(number, caller_id=None):
response = VoiceResponse()
d = Dial()
if number == PRIVATE_NUMBER:
p = Play("http://phone.ehnerd.com/music/intro.wav")
response.append(p)
d.number(number, url="/callscreen")
else:
d.number(number)
response.append(d)
return str(response)
def dial(numbers, flavor=''):
response = VoiceResponse()
for num in numbers:
dial = Dial()
dial.number(num)
response.append(dial)
if flavor:
response.say(flavor, voice='woman', language='en')
return str(response)
def call_reply():
phone_numbers_list = db.session.query(Contact).filter(
Contact.number == request.form["From"]).first().contacts.split(',')
db.session.remove()
print(phone_numbers_list, file=sys.stderr)
response = VoiceResponse()
dial = Dial()
for number in phone_numbers_list:
dial.number(number)
response.append(dial)
return str(response)
def twilio_dial_number(number):
if not "accept" in request.values.get("SpeechResult","accept").lower():
response = VoiceResponse()
response.reject()
return str(response)
response = VoiceResponse()
dial = Dial(answerOnBridge=True)
dial.number(number)
response.append(dial)
response.hangup()
return str(response)
def test_add_queue(self):
""" add a queue to a dial """
d = Dial()
d.queue('The Cute Queue')
r = VoiceResponse()
r.append(d)
assert_equal(
self.strip(r),
'<?xml version="1.0" encoding="UTF-8"?><Response><Dial><Queue>The Cute Queue</Queue></Dial></Response>'
)
def test_add_conference(self):
""" add a conference to a dial """
d = Dial()
d.conference('My Room')
r = VoiceResponse()
r.append(d)
assert_equal(
self.strip(r),
'<?xml version="1.0" encoding="UTF-8"?><Response><Dial><Conference>My Room</Conference></Dial></Response>'
)
def test_add_client(self):
""" add a client to a dial """
d = Dial()
d.client('alice')
r = VoiceResponse()
r.append(d)
assert_equal(
self.strip(r),
'<?xml version="1.0" encoding="UTF-8"?><Response><Dial><Client>alice</Client></Dial></Response>'
)