def ProviderIVR_LeaveMsg_Action(request):
"""
Step 2 of ProviderIVR_LeaveMsg_New - we get called back from getRecording process
based on ivr2_state. We save the message recorded and continue
TODO: if caller is a provider, we want to be able to hit the # key to go back to his voice mailbox
"""
provider = Provider.objects.get(id=request.session['provider_id'])
logger.debug(
'%s: ProviderIVR_LeaveMsg_Action provider %s state %s POST data %s' %
(request.session.session_key, provider,
request.session.get('ivr2_state', 'None'), str(request.POST)))
callEnded = _checkCallbackDuration(request, False)
if ('ivr2_Record_recording' in request.session):
# if caller is provider, we mask the callbacknumber; otherwise, show it in message
provider_qs = Provider.objects.filter(
mobile_phone=request.session['Caller'])
if (provider_qs):
request.session['ivr2_Record_callbacknumber'] = provider_qs[
0].mdcom_phone
subject = "Voice Mail from %s %s" % (provider_qs[0].first_name,
provider_qs[0].last_name)
else:
request.session['ivr2_Record_callbacknumber'] = request.session[
'Caller']
subject = "Voice Mail from %s" % request.session[
'ivr2_Record_callbacknumber']
# set up for save_message
request.session['ivr_makeRecording_recording'] = request.session[
'ivr2_Record_recording']
if ('ivr2_Record_callbacknumber' in request.session):
request.session[
'ivr_makeRecording_callbacknumber'] = request.session[
'ivr2_Record_callbacknumber']
del request.session['ivr2_Record_callbacknumber']
logger.debug(
'%s: ProviderIVR_LeaveMsg_Action recording url: %s callback %s'
% (request.session.session_key,
request.session['ivr_makeRecording_recording'],
request.session['ivr_makeRecording_callbacknumber']))
else:
logger.debug('%s: ProviderIVR_LeaveMsg_Action recording url: %s ' %
(request.session.session_key,
request.session['ivr_makeRecording_recording']))
_copyStateVariables(request)
save_message(request, subject, [provider.user], None, "VM", False)
del request.session['ivr2_Record_recording']
r = twilio.Response()
r.append(tts('Good bye'))
r.append(twilio.Hangup())
return HttpResponse(str(r), mimetype=settings.TWILIO_RESPONSE_MIMETYPE)
else:
# no recording? user might have hung up
logger.debug(
'%s: ProviderIVR_LeaveMsg_Action is called with no recording for provider %s'
% (request.session.session_key, request.session['provider_id']))
r = twilio.Response()
return HttpResponse(str(r), mimetype=settings.TWILIO_RESPONSE_MIMETYPE)
def Twilio_record_complete(request):
import cPickle
# Save debugging data
sid = request.POST['CallSid']
status = request.POST['CallStatus']
log = TwilioCallGatherTest.objects.get(callid=sid)
log.recordingurl = request.POST['RecordingUrl']
debugData = cPickle.loads(log.debug_data.encode('ascii'))
newEntry = ['Twilio_record_complete', cPickle.dumps(request.POST)]
debugData.append(newEntry)
log.debug_data = cPickle.dumps(debugData)
log.save()
# We don't care about which session this is associated with as all
# verification is the same across all sessions.
r = twilio.Response()
say = twilio.Say("Thank you. Goodbye.", voice=twilio.Say.MAN, language=twilio.Say.ENGLISH)
r.append(say)
hangup = twilio.Hangup()
r.append(hangup)
debugData.append(str(r))
log.debug_data = cPickle.dumps(debugData)
log.save()
return HttpResponse(str(r), mimetype=settings.TWILIO_RESPONSE_MIMETYPE)
def UnaffiliatedNumber(request):
r = twilio.Response()
r.append(twilio.Pause()) # one second pause keeps the first words from getting cut off.
r.append(tts(_("You have called an inactive phone number affiliated with "
"doctorcom. Please visit us online at w w w dot m d com dot com. Good bye.")))
r.append(twilio.Hangup())
return HttpResponse(str(r), mimetype=settings.TWILIO_RESPONSE_MIMETYPE)
def PracticeIVR_LeaveRegularMsg_New(request):
"""
3 steps:
1. get callback number
2. get message (recording) from caller
3. Sends office manager text message, in attachment there is voice file of recording
"""
callEnded = _checkCallbackDuration(request, False) # if someone hangs up, we still want to keep processing
logger.debug('%s: PracticeIVR_LeaveRegularMsg_New state %s' %
(request.session.session_key, request.session['ivr2_state']))
if ('ivr2_sub_state' not in request.session):
# first time around
request.session['ivr2_sub_state'] = 'PracticeIVR_LeaveRegularMsg_Start'
else:
logger.debug('%s: PracticeIVR_LeaveRegularMsg_New sub_state %s' %
(request.session.session_key, request.session['ivr2_sub_state']))
# we have recording, or callback number or we are in the GetMsg sub_state
if ('ivr2_Record_recording' in request.session or
('ivr2_only_callbacknumber' in request.session and
request.session['ivr2_only_callbacknumber'] == True) or
request.session['ivr2_sub_state'] == 'PracticeIVR_LeaveRegularMsg_GetMsg'):
# final or third iteration - get and send message
del request.session['ivr2_sub_state']
# get a list of all office managers for this practice
mgrs = get_all_practice_managers(request.session['practice_id'])
# after unique'ifying save_answering_service_message() expects recips
# as a list, see https://redmine.mdcom.com/issues/1374 for details
_copyStateVariables(request)
save_answering_service_message(request, False, list(set(m.user for m in mgrs)))
r = twilio.Response()
r.append(tts(_('Your message have been sent. Good Buy')))
r.append(twilio.Hangup())
return HttpResponse(str(r), mimetype=settings.TWILIO_RESPONSE_MIMETYPE)
if (request.session['ivr2_sub_state'] == 'PracticeIVR_LeaveRegularMsg_Start'):
# first iteration, getCallBackNumber
request.session['ivr2_sub_state'] = 'PracticeIVR_LeaveRegularMsg_GetCallback'
request.session['ivr2_returnOnHangup'] = \
'MHLogin.DoctorCom.IVR.views_practice_v2.PracticeIVR_LeaveRegularMsg_New'
return getCallBackNumberNew(request)
elif request.session['ivr2_sub_state'] == 'PracticeIVR_LeaveRegularMsg_GetCallback':
# second iteration, get Message recording
request.session['ivr2_sub_state'] = 'PracticeIVR_LeaveRegularMsg_GetMsg'
request.session['ivr2_Record_maxLength'] = 600 # 10 minutes
request.session['ivr2_Record_leadSilence'] = 2
request.session['ivr2_Record_promptOnce'] = True
request.session['ivr2_Record_prompt_str'] = 'Please say your \
non urgent message after the beep. Please state your name and \
speak clearly. Press pound when finished.'
request.session['ivr2_returnOnHangup'] = \
'MHLogin.DoctorCom.IVR.views_practice_v2.PracticeIVR_LeaveRegularMsg_New'
request.session.modified = True
# Pass off the recording action to the getRecording function.
return getQuickRecordingNew(request)
else:
# should never get here with unknown state
logger.info('%s: PracticeIVR_LeaveRegularMsg_New called with state %s' % (
request.session.session_key, request.session['ivr2_state']))
request.session['ivr2_state'] = 'PracticeIVR_LeaveRegularMsg_New'
return PracticeIVR_LeaveRegularMsg_New(request)
def testHangup(self):
"""convenience: should Hangup to a url via POST"""
r = Response()
r.append(twiml.Hangup())
r = self.strip(r)
self.assertEquals(
r,
'<?xml version="1.0" encoding="UTF-8"?><Response><Hangup /></Response>'
)
def testImproperNesting(self):
""" bad nesting """
verb = twiml.Gather()
self.assertRaises(TwimlException, verb.append, twiml.Gather())
self.assertRaises(TwimlException, verb.append, twiml.Record())
self.assertRaises(TwimlException, verb.append, twiml.Hangup())
self.assertRaises(TwimlException, verb.append, twiml.Redirect())
self.assertRaises(TwimlException, verb.append, twiml.Dial())
self.assertRaises(TwimlException, verb.append, twiml.Conference(""))
self.assertRaises(TwimlException, verb.append, twiml.Sms(""))
def improperAppend(self, verb):
self.assertRaises(TwimlException, verb.append, twiml.Say(""))
self.assertRaises(TwimlException, verb.append, twiml.Gather())
self.assertRaises(TwimlException, verb.append, twiml.Play(""))
self.assertRaises(TwimlException, verb.append, twiml.Record())
self.assertRaises(TwimlException, verb.append, twiml.Hangup())
self.assertRaises(TwimlException, verb.append, twiml.Reject())
self.assertRaises(TwimlException, verb.append, twiml.Redirect())
self.assertRaises(TwimlException, verb.append, twiml.Dial())
self.assertRaises(TwimlException, verb.append, twiml.Conference(""))
self.assertRaises(TwimlException, verb.append, twiml.Sms(""))
self.assertRaises(TwimlException, verb.append, twiml.Pause())
def PracticeIVR_ForwardCall_Vet(request):
"""
This function is executed on Number nouns within Dial verbs. The idea is to
try to determine if it's a human who picked up, or a machine. Alternatively,
this gives the called party a chance to send the call to voicemail without
the caller knowing they're rejecting the call.
"""
logger.debug('%s: PracticeIVR_ForwardCall_Vet ' % (request.session.session_key))
r = twilio.Response()
# First, find the recording to play
callSID = request.POST['CallSid']
# second leg calls have their own callSIDs - may need parentCallSID
(log, plog) = _getCallLogOrParent(request)
if (request.method == 'POST' and 'Digits' in request.POST):
# Connect the calls
log.call_connected = True
log.save()
if plog:
plog.call_connected = True
plog.save()
logger.debug('%s: PracticeIVR_ForwardCall_Vet update parent of logsid %s plogSID %s' %
(request.session.session_key, log.callSID, plog.callSID))
event = callEvent(callSID=callSID, event='C_ACC')
event.save()
return HttpResponse(str(r), mimetype=settings.TWILIO_RESPONSE_MIMETYPE)
caller_spoken_name = log.caller_spoken_name
gather = twilio.Gather(numDigits=1, finishOnKey='',
action=reverse('PracticeIVR_ForwardCall_Vet'))
if('click2call' in request.session):
gather.append(tts(_("You have a call from")))
gather.append(twilio.Play(caller_spoken_name))
gather.append(tts(_("Press any key to accept.")))
else:
gather.append(tts(_("You have an urgent answering service call from")))
gather.append(twilio.Play(caller_spoken_name))
gather.append(tts(_("Press any key to accept.")))
r.append(gather)
r.append(twilio.Hangup())
return HttpResponse(str(r), mimetype=settings.TWILIO_RESPONSE_MIMETYPE)
def ProviderIVR_ForwardCall_VetAnswer(request):
"""
This function is executed on Number nouns within Dial verbs. The idea is to
try to determine if it's a human who picked up, or a machine. Alternatively,
this gives the called party a chance to send the call to voicemail without
the caller knowing they're rejecting the call.
"""
r = twilio.Response()
request.session.modified = True
callSID = request.POST['CallSid']
log = callLog.objects.get(callSID=callSID)
if (request.method == 'POST' and 'Digits' in request.POST):
# Connect the calls
log.call_connected = True
log.save()
event = callEvent(callSID=callSID, event='C_ACC')
event.save()
return HttpResponse(str(r), mimetype=settings.TWILIO_RESPONSE_MIMETYPE)
caller_spoken_name = log.caller_spoken_name
if (log.mdcom_caller):
# Great. Is it a Provider?
if (isinstance(log.mdcom_caller, Provider)
and log.mdcom_caller.vm_config.count()):
vm_config = log.mdcom_caller.vm_config.get()
if (vm_config.config_complete):
caller_spoken_name = vm_config.name
gather = twilio.Gather(numDigits=1,
finishOnKey='',
action=reverse('ProviderIVR_ForwardCall_VetAnswer'))
gather.append(tts("You have a call from"))
gather.append(twilio.Play(caller_spoken_name))
gather.append(tts("Press any key to accept."))
r.append(gather)
r.append(twilio.Hangup())
return HttpResponse(str(r), mimetype=settings.TWILIO_RESPONSE_MIMETYPE)
def Twilio_callGather_complete(request):
import cPickle
# Save debugging data
sid = request.POST['CallSid']
status = request.POST['CallStatus']
key = request.POST['Digits']
log = TwilioCallGatherTest.objects.get(callid=sid)
debugData = cPickle.loads(log.debug_data.encode('ascii'))
newEntry = ['Twilio_callGather_complete', cPickle.dumps(request.POST)]
debugData.append(newEntry)
log.debug_data = cPickle.dumps(debugData)
log.save()
# We don't care about which session this is associated with as all
# verification is the same across all sessions.
r = twilio.Response()
if (key):
say = twilio.Say("You pressed the %s key" % (key, ),
voice=twilio.Say.MAN, language=twilio.Say.ENGLISH)
else:
say = twilio.Say("No key press was recorded.",
voice=twilio.Say.MAN, language=twilio.Say.ENGLISH)
r.append(say)
hangup = twilio.Hangup()
r.append(hangup)
log.success = log.success + '2' # should be 11 or 101 here
debugData.append(str(r))
log.debug_data = cPickle.dumps(debugData)
log.save()
return HttpResponse(str(r), mimetype=settings.TWILIO_RESPONSE_MIMETYPE)
def _hangup(self):
response = twiml.Hangup()
return response
def testBadAppend(self):
""" should raise exceptions for wrong appending """
self.improperAppend(twiml.Hangup())
def PracticeIVR_CallerResponse_Action(request, twilioResponse=None):
"""
This function process callers response in 2 ways:
old way (original answering service):
1=leave msg in doc com mailbox via PracticeIVR_LeaveRegularMsg_New (to all practice managers)
2=page doctor on call (LeaveUrgentMsg_New)
new way (dynamic greeting already called):
create greeting based on call_groups info in db
if 1 call group for THIS practice, take message via PracticeIVR_LeaveRegularMsg_New
if > 1 call group, add a layer to first pick call group, then pick type of message
PracticeIVR_ForwardCall_New
"""
practice = PracticeLocation.objects.get(id=request.session['practice_id'])
logger.debug('%s: PracticeIVR_CallerResponse_Action practice %s POST data is %s' % (
request.session.session_key, practice, str(request.POST)))
r = twilioResponse or twilio.Response()
if (request.method == 'POST' and 'Digits' in request.POST):
digits = request.POST['Digits']
if practice.uses_original_answering_serice(): # old way
logger.debug('%s: PracticeIVR_CallerResponse_Action via old ans svc' % (
request.session.session_key))
p = re.compile('[0-9#*]$')
if (not p.match(digits)):
r.append(tts(_('I\'m sorry, I didn\'t understand that.')))
elif (digits == '1'):
# leave msg in doctor com mailbox
request.session['ivr2_state'] = 'PracticeIVR_LeaveRegularMsg_New'
request.session.modified = True
return PracticeIVR_LeaveRegularMsg_New(request)
elif (digits == '2'):
# forward the call
request.session['ivr2_state'] = 'PracticeIVR_ForwardCall_New'
request.session.modified = True
request.session['provider_id'] = _getRecentOncallProviderId(request)
logger.debug('%s: PracticeIVR_CallerResponse_Action old ans svc NO oncall provider' %
(request.session.session_key))
if(not request.session['provider_id']):
r.append(tts(_('We\'re sorry, an application error has occurred. Goodbye.',
voice='woman')))
r.append(twilio.Hangup())
# return r
return HttpResponse(str(r), mimetype=settings.TWILIO_RESPONSE_MIMETYPE)
return PracticeIVR_ForwardCall_New(request)
elif (digits == '*'):
pass
else:
r.append(tts(_('I\'m sorry, I didn\'t understand that.')))
return PracticeIVR_CallerResponse_New(request, r)
else:
# new V2 dynamic greeting and call groups
call_groups_map = request.session['call_groups_map']
specialties_map = request.session['specialties_map']
logger.debug('%s: PracticeIVR_CallerResponse_Action via new ans svc cg %s sp %s' % (
request.session.session_key, call_groups_map, specialties_map))
gather = twilio.Gather(action=reverse('PracticeIVR_CallerResponse_Action'),
finishOnKey='', numDigits=1, timeout=60)
p = re.compile('[0-9]$')
if (not p.match(digits)):
r.append(tts(_('I\'m sorry, I didn\'t understand that.')))
r.append(tts(_('%s.') % (''.join(request.session['last_played']),)))
r.append(gather)
elif (digits == '1' and request.session['one_ok'] == '1'): # one_ok is set in create_dynamic_greeting
# leave msg in doctor com mailbox
request.session['ivr2_state'] = 'PracticeIVR_LeaveRegularMsg_New'
request.session.modified = True
return PracticeIVR_LeaveRegularMsg_New(request)
elif (digits in call_groups_map):
#Call Group reached, get provider on call
request.session['callgroup_id'] = call_groups_map.get(digits)
request.session['ivr2_state'] = 'PracticeIVR_ForwardCall_New'
request.session.modified = True
request.session['provider_id'] = _getRecentOncallProviderId(request)
logger.debug('%s: PracticeIVR_CallerResponse_Action new ans svc NO oncall provider' %
(request.session.session_key))
if(not request.session['provider_id']):
r.append(tts(_('We\'re sorry, an application error has occurred. Goodbye.',
voice='woman')))
r.append(twilio.Hangup())
# return r
return HttpResponse(str(r), mimetype=settings.TWILIO_RESPONSE_MIMETYPE)
return PracticeIVR_ForwardCall_New(request)
elif (digits in specialties_map):
#specialty reached, get list of call groups,
#populates request.session['call_groups_map'] and blanks out request.session['specialty_map']
call_groups_greeting = create_call_group_list(request, specialties_map.get(digits))
gather.append(tts(_('%s.') % (''.join(call_groups_greeting),)))
request.session['last_played'] = call_groups_greeting
r.append(gather)
#elif (digits == '*'): treat * as invalid input
#pass
else:
gather.append(tts(_('I\'m sorry, I didn\'t understand that.')))
gather.append(tts(_('%s.') % (''.join(request.session['last_played']),)))
r.append(gather)
return HttpResponse(str(r), mimetype=settings.TWILIO_RESPONSE_MIMETYPE)
else:
# should never happen - but if we get here without Digits, we log and go back to Main
logger.debug('%s: PracticeIVR_CallerResponse_Action is called with no post or digits' %
(request.session.session_key))
request.session['ivr2_state'] = 'PracticeIVR_Main_New'
return PracticeIVR_Main_New(request)
def ProviderIVR_ForwardCall_Vet(request):
"""
This function is executed on Number nouns within Dial verbs. The idea is to
try to determine if it's a human who picked up, or a machine. Alternatively,
this gives the called party a chance to send the call to voicemail without
the caller knowing they're rejecting the call.
"""
logger.debug('%s: ProviderIVR_ForwardCall_Vet POST %s' %
(request.session.session_key, str(request.POST)))
r = twilio.Response()
callSID = request.POST['CallSid']
# second leg calls have their own callSIDs - may need parentCallSID
(log, plog) = _getCallLogOrParent(request)
if (request.method == 'POST' and 'Digits' in request.POST):
# Connect the calls, get parent log if any
if log:
logger.debug(
'%s: ProviderIVR_ForwardCall_Vet connected callsid %s logSID %s'
% (request.session.session_key, callSID, log.callSID))
log.call_connected = True
log.save()
if plog:
plog.call_connected = True
plog.save()
logger.debug(
'%s: ProviderIVR_ForwardCall_Vet update parent of logsid %s plogSID %s'
% (request.session.session_key, log.callSID, plog.callSID))
else:
logger.debug(
'%s: ProviderIVR_ForwardCall_Vet connected log not found %s' %
(request.session.session_key, callSID))
event = callEvent(callSID=request.POST['CallSid'], event='C_ACC')
event.save()
return HttpResponse(str(r), mimetype=settings.TWILIO_RESPONSE_MIMETYPE)
if log:
caller_spoken_name = log.caller_spoken_name
if (log.mdcom_caller):
# Great. Is it a Provider?
if (isinstance(log.mdcom_caller, Provider)
and log.mdcom_caller.vm_config.count()):
vm_config = log.mdcom_caller.vm_config.get()
if (vm_config.config_complete):
caller_spoken_name = vm_config.name
else:
logger.debug(
'%s: ProviderIVR_ForwardCall_Vet call log sid %s not found' %
(request.session.session_key, callSID))
gather = twilio.Gather(numDigits=1,
finishOnKey='',
action=reverse('ProviderIVR_ForwardCall_Vet'))
gather.append(tts("You have a call from"))
gather.append(twilio.Play(caller_spoken_name))
gather.append(tts("Press any key to accept."))
r.append(gather)
r.append(twilio.Hangup())
return HttpResponse(str(r), mimetype=settings.TWILIO_RESPONSE_MIMETYPE)
def ProviderIVR_ForwardCall_New(request, provider=None, twilioResponse=None):
"""
new version of ProviderIVR_ForwardCall - forward call to dialed user as per user preference
called by ProviderIVR_Main_New
Steps:
1. get name
2. Dial - based on provider.forward_voicemail state to Mobile, office, other (VM already handled)
3. After dialed: handle failure by going to LeaveMsg or hangup?
"""
assert (request.session['provider_id'])
provider = Provider.objects.get(id=request.session['provider_id'])
logger.debug(
'%s: ProviderIVR_ForwardCall_New is initiated provider %s state %s substate %s POST %s'
% (request.session.session_key, provider,
request.session.get('ivr2_state', None),
request.session.get('ivr2_sub_state', None), str(request.POST)))
callEnded = _checkCallbackDuration(request, False)
# check user forwarding preference
forward = provider.forward_voicemail
if (forward == 'VM'):
# go to voicemail
request.session['ivr2_state'] = 'ProviderIVR_LeaveMsg_New'
logger.debug(
'%s: ProviderIVR_ForwardCall_New forwarding to voicemail of %s' %
(request.session.session_key, provider))
return ProviderIVR_LeaveMsg_New(request)
# State processing - 1. get caller name or ask for it
r = twilioResponse or twilio.Response()
if ('ivr2_sub_state' not in request.session):
request.session['ivr2_sub_state'] = 'ProviderIVR_ForwardCall_Start'
else:
logger.debug(
'%s: ProviderIVR_ForwardCall_New sub_state %s' %
(request.session.session_key, request.session['ivr2_sub_state']))
if (request.session['ivr2_sub_state'] == 'ProviderIVR_ForwardCall_Start'):
request.session['ivr2_sub_state'] = 'ProviderIVR_ForwardCall_GetName'
# is this a doctorcom user with recorded name?
callSID = request.POST['CallSid']
log = callLog.objects.get(callSID=callSID)
if (log.mdcom_caller and isinstance(log.mdcom_caller, Provider)):
if (log.mdcom_caller.vm_config.count()):
prov_vmconfig = log.mdcom_caller.vm_config.get()
if (prov_vmconfig.config_complete):
logger.debug('%s/%s: Found the caller\'s name!' % (
request.session.session_key,
request.session['ivr2_state'],
))
log.caller_spoken_name = prov_vmconfig.name
log.save()
# got the recorded name; just go back to the next step - Dial
return ProviderIVR_ForwardCall_New(request, provider,
r) # next step
else:
logger.debug(
'%s/%s: ProviderIVR_ForwardCall_New GetName: Caller\'s '
'vm_config incomplete!' %
(request.session.session_key,
request.session['ivr2_state']))
else:
logger.debug(
'%s/%s: ProviderIVR_ForwardCall_New GetName: unsuitable '
'number of vm_config objects found: %i' %
(request.session.session_key,
request.session['ivr2_state'],
log.mdcom_caller.vm_config.count()))
else:
logger.debug(
'%s/%s: ProviderIVR_ForwardCall_New GetName: mdcom_caller %s '
'either isn\'t defined or doesn\'t seem to be a Provider' %
(request.session.session_key, request.session['ivr2_state'],
str(log.mdcom_caller)))
# Not a user with a name recording. Get one.
# ivr2_state already set to ProviderIVR_ForwardCall_GetName
request.session[
'ivr2_Record_prompt_str'] = 'Please say your name after the tone.'
request.session['ivr2_Record_maxLength'] = 4
request.session['ivr2_Record_timeout'] = 2
request.session['ivr2_Record_leadSilence'] = 1
return getQuickRecordingNew(request)
elif (request.session['ivr2_sub_state'] ==
'ProviderIVR_ForwardCall_GetName'):
request.session['ivr2_sub_state'] = 'ProviderIVR_ForwardCall_Dial'
# save the caller name
callSID = request.POST['CallSid']
log = callLog.objects.get(callSID=callSID)
if (not log.caller_spoken_name):
log.caller_spoken_name = request.session['ivr2_Record_recording']
del request.session['ivr2_Record_recording']
log.save()
# Okay, let's find number to dial!
user_number = None
if (forward == 'MO'):
user_number = provider.user.mobile_phone
elif (forward == 'OF'):
user_number = provider.office_phone
elif (forward == 'OT'):
user_number = provider.user.phone
logger.debug(
'%s/%s: ProviderIVR_ForwardCall_New Dial user number is \'%s\' forward %s'
% (request.session.session_key, request.session['ivr2_state'],
user_number, forward))
if (not user_number):
# no flags were set.
if (provider.user.mobile_phone):
user_number = provider.user.mobile_phone
else:
return ProviderIVR_LeaveMsg_New(request, r)
# when dial action is done, we go back to its actionurl - which is here with state Dial
dial = twilio.Dial(
action=reverse('ProviderIVR_ForwardCall_New'),
timeout=22,
timeLimit=14400, # 4 hours
callerId=_makeUSNumber(request.session['Caller']))
# we also want to allow call vetting
dial.append(
twilio.Number(user_number,
url=reverse('ProviderIVR_ForwardCall_Vet')))
r.append(dial)
# If the call did not connect, we go to LeaveMsg
r.append(twilio.Redirect(reverse('ProviderIVR_LeaveMsg_New')))
return HttpResponse(str(r), mimetype=settings.TWILIO_RESPONSE_MIMETYPE)
elif (request.session['ivr2_sub_state'] == 'ProviderIVR_ForwardCall_Dial'):
# done with forward call
del request.session['ivr2_sub_state']
# need to get parent call log for caller and connected; also update child log for duration
(log, plog) = _getCallLogOrParent(request)
if log:
logger.debug(
'%s/%s: ProviderIVR_ForwardCall_New state connected %s' %
(request.session.session_key, request.session['ivr2_state'],
str(log.call_connected)))
else:
logger.debug(
'%s/%s: ProviderIVR_ForwardCall_New state no log SID %s' %
(request.session.session_key, request.session['ivr2_state'],
request.POST['CallSid']))
if ('DialCallStatus' in request.POST):
if (request.POST['DialCallStatus'] == 'completed'):
# update child log call duration
diallog = callLog.objects.get(
callSID=request.POST['DialCallSid'])
if diallog:
diallog.call_duration = request.POST['DialCallDuration']
diallog.save()
logger.debug(
'%s: ProviderIVR_ForwardCall_New update child diallog '
'dialSid %s duration %s' %
(request.session.session_key,
request.POST['DialCallSid'],
request.POST['DialCallDuration']))
else:
logger.debug(
'%s: ProviderIVR_ForwardCall_New diallog not found: dialSid %s duration %s'
% (request.session.session_key,
request.POST['DialCallSid'],
request.POST['DialCallDuration']))
# Do nothing so that the second leg call continues un-interrupted
return HttpResponse(str(r),
mimetype=settings.TWILIO_RESPONSE_MIMETYPE)
else:
# (request.POST['DialCallStatus'] != 'completed'):
logger.debug(
'%s/%s: ProviderIVR_ForwardCall_New DialStatus not answered'
% (request.session.session_key,
request.session['ivr2_state']))
if (request.POST['DialCallStatus'] == 'failed'):
# TODO: Figure out how to deal with connection problems. Most
# likely, send an email to the user and administrators.
logger.debug(
'%s/%s: ProviderIVR_ForwardCall_New DialStatus failed'
% (request.session.session_key,
request.session['ivr2_state']))
subject = 'ProviderIVR_ForwardCall Call Forward DialStatus Fail'
message = 'ProviderIVR_ForwardCall got DialStatus failed. Post data: %s' \
% (str(request.POST),)
mail_admins(subject=subject,
message=message,
fail_silently=False)
# else request.POST['DialStatus'] == 'busy' or request.POST['DialStatus'] == 'no-answer'
return ProviderIVR_LeaveMsg_New(request, r)
# if we connected (in Vet), we hang up here
if (log.call_connected):
r.append(twilio.Hangup())
return HttpResponse(str(r),
mimetype=settings.TWILIO_RESPONSE_MIMETYPE)
# if not connected, we go to LeaveMsg
return ProviderIVR_LeaveMsg_New(request, r)
def PracticeIVR_LeaveUrgentMsg_New(request):
"""
This lets caller leave an urgent message for a practice in foll steps:
1. get callback number
2. Records a voicemail message for the doctor on call
3. leave notification to the doctor based on preferences.
"""
# TODO:
# Update this code so that users can hit the pound key to pop back and log
# into their own voicemail box.
requestDataDict = {"GET": request.GET, "POST": request.POST}[request.method]
logger.debug('%s: PracticeIVR_LeaveUrgentMsg_New state %s POST data is %s' % (
request.session.session_key, request.session['ivr2_state'], str(request.POST)))
# if caller hangs up, we still continue
if ('ivr2_sub_state' not in request.session):
request.session['ivr2_sub_state'] = 'PracticeIVR_LeaveUrgentMsg_Start'
else:
logger.debug('%s: PracticeIVR_LeaveUrgentMsg_New sub_state %s' % (
request.session.session_key, request.session['ivr2_sub_state']))
callEnded = _checkCallbackDuration(request, False)
if (callEnded):
logger.debug('%s: PracticeIVR_LeaveUrgentMsg_New caller hung up. State %s' % (
request.session.session_key, request.session.get('ivr2_sub_state', 'None')))
# we deal with leftover recording or , if any
if (request.session['ivr2_sub_state'] == 'PracticeIVR_LeaveUrgentMsg_GetMsg' or
'ivr2_Record_recording' in request.session or
('ivr2_only_callbacknumber' in request.session and
request.session['ivr2_only_callbacknumber'] == True)):
# send msg to office managers
del request.session['ivr2_sub_state']
provider = Provider.objects.get(id=_getRecentOncallProviderId(request))
logger.debug('%s: PracticeIVR_LeaveUrgentMsg_New caller hung up -- saving urgent msg for %s' % (
request.session.session_key, provider))
config = None
config_complete = provider.vm_config.count() == 1 and provider.vm_config.get().config_complete
if (config_complete):
config = provider.vm_config.get()
mgrs = get_all_practice_managers(request.session['practice_id'])
_copyStateVariables(request)
save_answering_service_message(request, True, [provider],
list(set(m.user for m in mgrs)))
else:
if (request.session['ivr2_sub_state'] == 'PracticeIVR_LeaveUrgentMsg_Start'):
# step 1: get callback number
request.session['ivr2_sub_state'] = 'PracticeIVR_LeaveUrgentMsg_GetCallback'
request.session['ivr2_returnOnHangup'] = \
'MHLogin.DoctorCom.IVR.views_practice_v2.PracticeIVR_LeaveUrgentMsg_New'
return getCallBackNumberNew(request)
elif request.session['ivr2_sub_state'] == 'PracticeIVR_LeaveUrgentMsg_GetCallback':
# step 2: after getting callback number, we get caller's message
request.session['ivr2_sub_state'] = 'PracticeIVR_LeaveUrgentMsg_GetMsg'
request.session['ivr2_Record_prompt_str'] = 'Please say your message \
for the doctor on call after the beep. Press pound when finished.'
request.session['ivr2_Record_maxLength'] = 600 # 10 minutes
request.session['ivr2_Record_leadSilence'] = 2
request.session['ivr2_Record_promptOnce'] = True
request.session['ivr2_returnOnHangup'] = \
'MHLogin.DoctorCom.IVR.views_practice_v2.PracticeIVR_LeaveUrgentMsg_New'
request.session.modified = True
# Pass off the recording action to the getRecording function.
return getQuickRecordingNew(request)
elif (request.session['ivr2_sub_state'] == 'PracticeIVR_LeaveUrgentMsg_GetMsg' or
'ivr2_Record_recording' in request.session or
('ivr2_only_callbacknumber' in request.session and
request.session['ivr2_only_callbacknumber'] == True)):
# step 3 - send msg to office managers
del request.session['ivr2_sub_state']
provider = Provider.objects.get(id=_getRecentOncallProviderId(request))
logger.debug('%s: PracticeIVR_LeaveUrgentMsg_New saving urgent msg for %s' % (
request.session.session_key, provider))
config = None
config_complete = provider.vm_config.count() == 1 and provider.vm_config.get().config_complete
if (config_complete):
config = provider.vm_config.get()
mgrs = get_all_practice_managers(request.session['practice_id'])
_copyStateVariables(request)
save_answering_service_message(request, True, [provider],
list(set(m.user for m in mgrs)))
#if pager number is entered, also page call back number
r = twilio.Response()
r.append(tts(_('Your message has been sent. Good bye')))
r.append(twilio.Hangup())
return HttpResponse(str(r), mimetype=settings.TWILIO_RESPONSE_MIMETYPE)
else: # should not get here
logger.debug('%s: Into PracticeIVR_LeaveUrgentMsg_New with invalid ivr2_state %s' %
(request.session.session_key, request.session['ivr2_state']))
request.session['ivr2_state'] = 'PracticeIVR_LeaveUrgentMsg_New'
return PracticeIVR_LeaveUrgentMsg_New(request)
def PracticeIVR_ForwardCall_New(request, twilioResponse=None):
"""
Forward the call to the dialed user, there are no preferences
for office managers, just call their cell phone
Done in 3 steps:
1. get caller name
2. forward call
3. if connected, done; if fail to connect, go to LeaveUrgentMsg_New
"""
provider = None
forward = None
try:
provider = Provider.objects.get(id=request.session['provider_id'])
if(not 'ProviderIVR_ForwardCall_forward' in request.session):
request.session['ProviderIVR_ForwardCall_forward'] = provider.forward_anssvc
forward = provider.forward_anssvc
except Provider.DoesNotExist:
pass
logger.debug('%s: PracticeIVR_ForwardCall_New provider %s practice %s state %s substate %s' % (
request.session.session_key, provider, request.session.get('practice_id', None),
request.session.get('ivr2_state', None), request.session.get('ivr2_sub_state', None)))
callSID = request.POST['CallSid']
# TODO - what if we don't get the callLog?
log = callLog.objects.get(callSID=callSID)
log.call_source = 'AS'
log.save()
if('click2call' in request.session):
forward = 'MO' # hack to keep click2call working
if(forward == 'VM'):
request.session['ivr2_state'] = 'PracticeIVR_LeaveUrgentMsg_New'
logger.debug('%s: PracticeIVR_ForwardCall_New forward to VM - LeaveUrgentMsg_New to %s' % (
request.session.session_key, provider))
return PracticeIVR_LeaveUrgentMsg_New(request)
r = twilioResponse or twilio.Response()
if ('ivr2_sub_state' not in request.session):
request.session['ivr2_sub_state'] = 'PracticeIVR_ForwardCall_Start'
else:
logger.debug('%s: PracticeIVR_ForwardCall_New sub_state %s' % (
request.session.session_key, request.session['ivr2_sub_state']))
# now we get caller name, dial and handle failure to connect by going to leave urgent message
if (request.session['ivr2_sub_state'] == 'PracticeIVR_ForwardCall_Start'):
request.session['ivr2_sub_state'] = 'PracticeIVR_ForwardCall_GetName'
# Is the user a DoctorCom user with a recorded name?
if (log.mdcom_caller and isinstance(log.mdcom_caller, Provider)):
if (log.mdcom_caller.vm_config.count()):
prov_vmconfig = log.mdcom_caller.vm_config.get()
if (prov_vmconfig.config_complete):
logger.debug('%s/%s sub %s: Found the caller\'s name! Forwarding call' % (
request.session.session_key, request.session['ivr2_state'],
request.session['ivr2_sub_state'],
))
log.caller_spoken_name = prov_vmconfig.name
log.save()
return PracticeIVR_ForwardCall_New(request, r) # restart execution of this function
else:
logger.debug('%s/%s sub %s: Caller\'s vm_config incomplete!' % (
request.session.session_key, request.session['ivr2_state'],
request.session['ivr2_sub_state'],
))
else:
logger.debug('%s/%s sub %s: An unsuitable number of vm_config objects found: %i' % (
request.session.session_key, request.session['ivr2_state'],
request.session['ivr2_sub_state'],
log.mdcom_caller.vm_config.count(),
))
else:
logger.debug('%s/%s sub %s: mdcom_caller %s either isn\'t defined or doesn\'t seem to be a Provider' % (
request.session.session_key, request.session['ivr2_state'],
request.session['ivr2_sub_state'],
str(log.mdcom_caller),
))
# Okay, it's not a user with a name recording. Get one.
request.session['ivr2_Record_prompt_str'] = 'Please say your name after the tone.'
request.session['ivr2_Record_maxLength'] = 4
request.session['ivr2_Record_timeout'] = 2
request.session['ivr2_Record_leadSilence'] = 1
return getQuickRecordingNew(request)
elif (request.session['ivr2_sub_state'] == 'PracticeIVR_ForwardCall_GetName'):
request.session['ivr2_sub_state'] = 'PracticeIVR_ForwardCall_Dial'
# save caller name
logger.debug('%s/%s: Set session to %s' % (
request.session.session_key, request.session['ivr2_state'],
request.session['ivr2_sub_state']
))
if (not log.caller_spoken_name):
log.caller_spoken_name = request.session['ivr2_Record_recording']
del request.session['ivr2_Record_recording']
log.save()
# now find the number to dial
user_number = ''
try:
office_staff = OfficeStaff.objects.get(user=request.session['provider_id']) # manager being called
logger.debug('%s/%s: got office staff \'%s\' \'%s\' with id %s office phone \'%s\'.' % (
request.session.session_key,
request.session['ivr2_state'],
office_staff.user.first_name,
office_staff.user.last_name,
office_staff.pk,
office_staff.user.mobile_phone,
))
user_number = office_staff.user.mobile_phone
except OfficeStaff.DoesNotExist:
#it's a provider
if(forward == 'MO'):
user_number = provider.mobile_phone
elif(forward == 'OF'):
user_number = provider.office_phone
elif(forward == 'OT'):
user_number = provider.phone
logger.debug('%s/%s: Setting user_number to \'%s\'' % (
request.session.session_key,
request.session['ivr2_state'],
user_number,
))
logger.debug('%s/%s: Tried to get called\'s number. Got \'%s\'' % (
request.session.session_key,
request.session['ivr2_state'],
user_number,
))
dial = twilio.Dial(
action=reverse('PracticeIVR_ForwardCall_New'),
timeout=22,
timeLimit=14400, # 4 hours
callerId=request.session['Caller'],
)
dial.append(twilio.Number(user_number,
url=reverse('PracticeIVR_ForwardCall_Vet')
))
r.append(dial)
r.append(twilio.Redirect(reverse('PracticeIVR_LeaveUrgentMsg_New')))
return HttpResponse(str(r), mimetype=settings.TWILIO_RESPONSE_MIMETYPE)
elif (request.session['ivr2_sub_state'] == 'PracticeIVR_ForwardCall_Dial'):
del request.session['ivr2_sub_state']
(clog, plog) = _getCallLogOrParent(request)
if clog:
logger.debug('%s/%s: PracticeIVR_ForwardCall_New state connected %s' % (
request.session.session_key, request.session['ivr2_state'],
str(clog.call_connected)))
else:
logger.debug('%s/%s: ProviderIVR_ForwardCall_New state no log SID %s' % (
request.session.session_key, request.session['ivr2_state'],
request.POST['CallSid']))
if ('DialCallStatus' in request.POST):
if (request.POST['DialCallStatus'] == 'completed'):
# update child log call duration
diallog = callLog.objects.get(callSID=request.POST['DialCallSid'])
if diallog:
diallog.call_duration = request.POST['DialCallDuration']
diallog.save()
logger.debug('%s: PracticeIVR_ForwardCall_New update child diallog dialSid %s duration %s' % (
request.session.session_key, request.POST['DialCallSid'], request.POST['DialCallDuration']))
else:
logger.debug('%s: PracticeIVR_ForwardCall_New diallog not found: dialSid %s duration %s' % (
request.session.session_key, request.POST['DialCallSid'], request.POST['DialCallDuration']))
# Do nothing so that the second leg call continues un-interrupted
return HttpResponse(str(r), mimetype=settings.TWILIO_RESPONSE_MIMETYPE)
if (clog.call_connected):
r.append(twilio.Hangup())
return HttpResponse(str(r), mimetype=settings.TWILIO_RESPONSE_MIMETYPE)
r.append(tts("The provider is not available right now."))
r.append(twilio.Redirect(reverse('PracticeIVR_LeaveUrgentMsg_New')))
# redirecting to LeaveUrgentMsg_New
request.session['ivr2_state'] = 'PracticeIVR_LeaveUrgentMsg_New'
return HttpResponse(str(r), mimetype=settings.TWILIO_RESPONSE_MIMETYPE)
else:
# else: Do nothing so that the call continues un-interrupted
return HttpResponse(str(r), mimetype=settings.TWILIO_RESPONSE_MIMETYPE)
def ProviderIVR_LeaveMsg(request):
"""
Records a voicemail message.
Arguments:
request - The standard Django request argument
request.session Keys:
provider_id - The ID of the Provider user who owns this voicemail box.
"""
# TODO: Update this code so that users can hit the pound key to
# pop back and log into their own voicemail box.
provider = Provider.objects.get(id=request.session['provider_id'])
config = None
config_complete = provider.vm_config.count(
) == 1 and provider.vm_config.get().config_complete
if (config_complete):
config = provider.vm_config.get()
if ('CallStatus' in request.POST
and request.POST['CallStatus'] == 'completed'):
try:
callSID = request.POST['CallSid']
auth, uri, = client.auth, client.account_uri
resp = make_twilio_request('GET',
uri + '/Calls/%s' % callSID,
auth=auth)
content = json.loads(resp.content)
log = callLog.objects.get(callSID=callSID)
log.call_duration = content['TwilioResponse']['Call']['Duration']
log.save()
except:
pass # this is really ugly, but letting this exception fall through
# destroys a message analytics will pick up the duration later on if it's missing
if ('ivr_makeRecording_recording' in request.session):
provider_qs = Provider.objects.filter(
mobile_phone=request.session['Caller'])
if (provider_qs):
request.session['ivr_makeRecording_callbacknumber'] = provider_qs[
0].mdcom_phone
subject = "Voice Mail from %s %s" % (provider_qs[0].first_name,
provider_qs[0].last_name)
else:
request.session[
'ivr_makeRecording_callbacknumber'] = request.session['Caller']
subject = "Voice Mail from %s" % request.session[
'ivr_makeRecording_callbacknumber']
save_message(request, subject, [provider.user], None, "VM", False)
request.session.pop('ivr_makeRecording_recording')
r = twilio.Response()
r.append(tts('Good bye'))
r.append(twilio.Hangup())
return HttpResponse(str(r), mimetype=settings.TWILIO_RESPONSE_MIMETYPE)
# Get the configuration file for this Provider
if (not config_complete):
# FIXME:
# Probably not the best way to create the spoken number. We need to
# break the number down so that there are spaces between each digit, and
# so that there are commas after the third and sixth digits.
if (not 'Called' in request.session
or (not request.session['Called'])):
# This will occur if click2call calls this function
request.session['ivr_makeRecording_prompt'] = tts(
'The user is not available. '
'Please leave a message after the beep. Press pound when finished for options.'
)
else:
number = request.session['Called']
spoken_number = []
[spoken_number.extend([i, ' ']) for i in number]
spoken_number.pop() # drop the last element
spoken_number.insert(5, ',')
spoken_number.insert(12, ',')
request.session['ivr_makeRecording_prompt'] = tts(
'The person at %s '
'is not available. Please leave a message after the beep. Press pound '
'when finished for options.' % (''.join(spoken_number), ))
else:
p = re.compile('http')
if (p.match(config.greeting)):
# This is a Twilio recording.
request.session['ivr_makeRecording_prompt'] = twilio.Play(
config.greeting)
else:
# TODO:
raise Exception('Unimplemented playback of local files')
request.session['ivr_makeRecording_maxLength'] = 120 # 2 minutes
request.session['ivr_makeRecording_leadSilence'] = 2
request.session['ivr_makeRecording_promptOnce'] = True
request.session['ivr_makeRecording_returnOnHangup'] = \
'MHLogin.DoctorCom.IVR.views_provider.ProviderIVR_LeaveMsg'
request.session['ivr_call_stack'].append('ProviderIVR_LeaveMsg')
request.session.modified = True
# Pass off the recording action to the getRecording function.
return getRecording(request)
def authenticateSession(request, twilioResponse=None):
"""
:param request: The standard Django request argument
:param request.session Keys: config_id - The ID of the VMBox_Config object
pertaining to the current voicemail session.
:param twilioResponse: A twilio response object. Use this to pass in any verbs
that should be run before the prompt. Note that any verbs passed
in will be lost on subsequent runs through this function (e.g.,
when the user enters an incorrect pin)
:returns: django.http.HttpResponse -- the result
"""
r = twilioResponse or twilio.Response()
if (not 'pin_errCount' in request.session):
request.session['pin_errCount'] = 0
if 'Digits' in request.POST:
call_sid = request.POST['CallSid']
digits = request.POST['Digits']
p = re.compile('\d{4,8}#?$')
if (p.match(digits)):
if ('answering_service' in request.session and
request.session['answering_service'] == 'yes'):
practice = PracticeLocation.objects.get(id=request.session['practice_id'])
if (practice.verify_pin(digits)):
request.session['authenticated'] = True
r.append(twilio.Redirect(reverse(request.session['ivr_call_stack'].pop())))
request.session.modified = True
return HttpResponse(str(r), mimetype=settings.TWILIO_RESPONSE_MIMETYPE)
else:
user = authenticate(config_id=request.session['config_id'], pin=digits)
if (user):
login(request, user)
# TESTING_KMS_INTEGRATION
uprivs = UserPrivateKey.objects.filter(user=user,
credtype=CRED_IVRPIN, gfather=True)
if uprivs.exists():
config = VMBox_Config.objects.get(id=request.session['config_id'])
config.change_pin(request, new_pin=digits)
request.session['authenticated'] = True
event = callEvent(callSID=call_sid, event='V_ASU')
event.save()
r.append(twilio.Redirect(reverse(request.session['ivr_call_stack'].pop())))
request.session.modified = True
response = HttpResponse(str(r), mimetype=settings.TWILIO_RESPONSE_MIMETYPE)
store_user_key(request, response, digits)
return response
event = callEvent(callSID=call_sid, event='V_AFL')
event.save()
r.append(tts('An in valid pin was entered.'))
request.session['pin_errCount'] += 1
if (request.session['pin_errCount'] >= 3): # give the user three erroneous pin entries.
r.append(tts('Good bye.'))
r.append(twilio.Hangup())
return HttpResponse(str(r), mimetype=settings.TWILIO_RESPONSE_MIMETYPE)
# This is the code that gets executed on the first run of this function.
gather = twilio.Gather(numDigits=8, action=reverse('authenticateSession'))
gather.append(tts(_("Please enter your pin number. Press pound to finish.")))
r.append(gather)
return HttpResponse(str(r), mimetype=settings.TWILIO_RESPONSE_MIMETYPE)
def ProviderIVR_ForwardCall(request):
"""Forward the call to the dialed user, as per the user's preferences.
Uses the following session variables:
ProviderIVR_ForwardCall_state: The most recent "state" of execution. May
have the following values:
- None/Undefined/Empty String: First execution of this function.
- Getting_Name: Getting the caller's name, if one hasn't been
defined.
- Dialing: Phone(s) have been dialed, and waiting for a response Caller
"""
r = twilio.Response()
request.session.modified = True
provider = Provider.objects.get(id=request.session['provider_id'])
if ('CallStatus' in request.POST
and request.POST['CallStatus'] == 'completed'):
if ('Duration' in request.POST):
callSID = request.POST['CallSid']
log = callLog.objects.get(callSID=callSID)
log.call_duration = request.POST['Duration']
log.save()
if (not 'ProviderIVR_ForwardCall_forward' in request.session):
request.session[
'ProviderIVR_ForwardCall_forward'] = provider.forward_voicemail
forward = provider.forward_voicemail
if (forward == 'VM'):
return ProviderIVR_LeaveMsg(request)
if (not 'ProviderIVR_ForwardCall_state' in request.session
or not request.session['ProviderIVR_ForwardCall_state']):
# New call. First, check to see if we should go straight to voicemail
# Okay, the call isn't going to voicemail directly. Now, set state.
request.session['ProviderIVR_ForwardCall_state'] = 'Getting_Name'
# Now, get the caller's name
# Is the user a DoctorCom user with a recorded name?
callSID = request.POST['CallSid']
log = callLog.objects.get(callSID=callSID)
if (log.mdcom_caller and isinstance(log.mdcom_caller, Provider)):
if (log.mdcom_caller.vm_config.count()):
prov_vmconfig = log.mdcom_caller.vm_config.get()
if (prov_vmconfig.config_complete):
logger.debug('%s/%s: Found the caller\'s name!' % (
request.session.session_key,
request.session['ProviderIVR_ForwardCall_state'],
))
log.caller_spoken_name = prov_vmconfig.name
log.save()
return ProviderIVR_ForwardCall(
request) # restart execution of this function
else:
logger.debug('%s/%s: Caller\'s vm_config incomplete!' % (
request.session.session_key,
request.session['ProviderIVR_ForwardCall_state'],
))
else:
logger.debug(
'%s/%s: An unsuitable number of vm_config objects found: %i'
% (
request.session.session_key,
request.session['ProviderIVR_ForwardCall_state'],
log.mdcom_caller.vm_config.count(),
))
else:
logger.debug(
'%s/%s: mdcom_caller %s either isn\'t defined or doesn\'t '
'seem to be a Provider' % (
request.session.session_key,
request.session['ProviderIVR_ForwardCall_state'],
str(log.mdcom_caller),
))
# Okay, it's not a user with a name recording. Get one.
request.session['ivr_call_stack'].append('ProviderIVR_ForwardCall')
request.session['ivr_makeRecording_prompt'] = \
tts('Please say your name after the tone.')
request.session['ivr_makeRecording_maxLength'] = 4
request.session['ivr_makeRecording_timeout'] = 2
request.session['ivr_makeRecording_leadSilence'] = 1
return getQuickRecording(request)
if (request.session['ProviderIVR_ForwardCall_state'] == 'Getting_Name'):
request.session['ProviderIVR_ForwardCall_state'] = 'Dialed'
logger.debug('%s/%s: Set session to %s' % (
request.session.session_key,
request.session['ProviderIVR_ForwardCall_state'],
request.session['ProviderIVR_ForwardCall_state'],
))
callSID = request.POST['CallSid']
log = callLog.objects.get(callSID=callSID)
if (not log.caller_spoken_name):
log.caller_spoken_name = request.session.pop(
'ivr_makeRecording_recording')
log.save()
logger.debug('%s/%s: got provider \'%s\' \'%s\' with id %s' % (
request.session.session_key,
request.session['ProviderIVR_ForwardCall_state'],
provider.first_name,
provider.last_name,
provider.pk,
))
logger.debug(
'%s/%s: Provider phone is \'%s\' and forward_other is \'%s\'' % (
request.session.session_key,
request.session['ProviderIVR_ForwardCall_state'],
provider.user.phone,
str(provider.forward_other),
))
# Okay, let's dial!
user_number = None
if (forward == 'MO'):
logger.debug('%s/%s: provider.forward_mobile True' % (
request.session.session_key,
request.session['ProviderIVR_ForwardCall_state'],
))
user_number = provider.user.mobile_phone
logger.debug('%s/%s: Setting user_number to \'%s\'' % (
request.session.session_key,
request.session['ProviderIVR_ForwardCall_state'],
provider.user.mobile_phone,
))
elif (forward == 'OF'):
logger.debug('%s/%s: provider.forward_office True' % (
request.session.session_key,
request.session['ProviderIVR_ForwardCall_state'],
))
user_number = provider.office_phone
logger.debug('%s/%s: Setting user_number to \'%s\'' % (
request.session.session_key,
request.session['ProviderIVR_ForwardCall_state'],
provider.office_phone,
))
elif (forward == 'OT'):
logger.debug('%s/%s: provider.forward_other True' % (
request.session.session_key,
request.session['ProviderIVR_ForwardCall_state'],
))
user_number = provider.user.phone
logger.debug('%s/%s: Setting user_number to \'%s\'' % (
request.session.session_key,
request.session['ProviderIVR_ForwardCall_state'],
provider.user.phone,
))
logger.debug('%s/%s: Tried to get called\'s number. Got \'%s\'' % (
request.session.session_key,
request.session['ProviderIVR_ForwardCall_state'],
user_number,
))
logger.debug(
'%s/%s: Provider phone is \'%s\' and forward_other is \'%s\'' % (
request.session.session_key,
request.session['ProviderIVR_ForwardCall_state'],
provider.user.phone,
str(provider.forward_other),
))
if (not user_number):
# no flags were set.
if (provider.user.mobile_phone):
user_number = provider.user.mobile_phone
else:
return ProviderIVR_LeaveMsg(request)
dial = twilio.Dial(
action=reverse('ProviderIVR_ForwardCall'),
timeout=22,
timeLimit=14400, # 4 hours
callerId=request.session['Caller'])
dial.append(
twilio.Number(user_number,
url=reverse('ProviderIVR_ForwardCall_VetAnswer')))
r.append(dial)
r.append(twilio.Redirect(reverse('ProviderIVR_LeaveMsg')))
return HttpResponse(str(r), mimetype=settings.TWILIO_RESPONSE_MIMETYPE)
if (request.session['ProviderIVR_ForwardCall_state'] == 'Dialed'):
callSID = request.POST['CallSid']
log = callLog.objects.get(callSID=callSID)
if (log.call_connected):
r.append(twilio.Hangup())
return HttpResponse(str(r),
mimetype=settings.TWILIO_RESPONSE_MIMETYPE)
return ProviderIVR_LeaveMsg(request)
r = twilio.Response()
if (request.POST['DialStatus'] != 'answered'):
if (request.POST['DialStatus'] == 'failed'):
# TODO: Figure out how to deal with connection problems. Most
# likely, send an email to the user and administrators.
subject = 'ProviderIVR_ForwardCall Call Forward DialStatus Fail'
message = 'ProviderIVR_ForwardCall got DialStatus failed. Post data: %s' % \
(str(request.POST),)
mail_admins(subject=subject, message=message, fail_silently=False)
# else request.POST['DialStatus'] == 'busy' or request.POST['DialStatus'] == 'no-answer'
return ProviderIVR_LeaveMsg(request)
# else: Do nothing so that the call continues un-interrupted
return HttpResponse(str(r), mimetype=settings.TWILIO_RESPONSE_MIMETYPE)
