Ejemplo n.º 1
0
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)
Ejemplo n.º 2
0
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)
Ejemplo n.º 3
0
def ProviderIVR_Status(request):
	"""
	callback for call status at the end of call
	first we need to check if there are unhandled state we need to wrap up
	then we get the call back duration and fill the call log
	"""
	logger.debug('%s: ProviderIVR_Status POST data is %s' % 
		(request.session.session_key, str(request.POST)))
#	state = request.session.get('ivr2_state', 'None')
#	logger.debug('%s: ProviderIVR_Status state is %s' %
#		(request.session.session_key, state))
	# wrap up if user was in the process of leaving a msg
	return _checkCallbackDuration(request, returnflag=True)
Ejemplo n.º 4
0
def ProviderIVR_Status(request):
    """
	callback for call status at the end of call
	first we need to check if there are unhandled state we need to wrap up
	then we get the call back duration and fill the call log
	"""
    logger.debug('%s: ProviderIVR_Status POST data is %s' %
                 (request.session.session_key, str(request.POST)))
    #	state = request.session.get('ivr2_state', 'None')
    #	logger.debug('%s: ProviderIVR_Status state is %s' %
    #		(request.session.session_key, state))
    # wrap up if user was in the process of leaving a msg
    return _checkCallbackDuration(request, returnflag=True)
Ejemplo n.º 5
0
def PracticeIVR_Status(request):
	"""
	callback for call status at the end of call
	first we need to check if there are unhandled state we need to wrap up (mainly from getting recording)
	then we get the call back duration and fill the call log
	"""
	state = request.session.get('ivr2_state', 'None')
	logger.debug('%s: PracticeIVR_Status POST %s state is %s' %
		(request.session.session_key, str(request.POST), state))
#	if state == 'PracticeIVR_LeaveRegularMsg_New':
#		return PracticeIVR_LeaveRegularMsg_New(request)
#	elif state == 'PracticeIVR_LeaveUrgentMsg_New':
#		return PracticeIVR_LeaveUrgentMsg_New(request)
#	else:
	return _checkCallbackDuration(request)
Ejemplo n.º 6
0
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)
Ejemplo n.º 7
0
def ProviderIVR_Main_New(request):
	"""
	initial call into provider -- Only called with new Twilio 2010 API
	initializes caller, called, provider_id, callLog and mask caller number with 
	doctorcom Number if caller has a doctorcom number
	I leave the numbers with + and country code but strip them off the number of 
	caller/called when we lookup the database for provider or mhluser
	"""
	if (not 'ivr2_state' in request.session):
		# beginning of the very first call
		request.session['ivr2_state'] = 'ProviderIVR_Main_New'
		logger.debug('%s: ProviderIVR_Main_New is initiated' % (request.session.session_key))
	elif (request.session['ivr2_state'] and (request.session['ivr2_state'] != 'ProviderIVR_Main_New') and
		(request.session['ivr2_state'] != 'ProviderIVR_TreeRoot_New')):
		# this shouldn't happen, but if it did, and we log and keep going
		if (not 'provider_id' in request.session):
			logger.debug('%s: ProviderIVR_Main_New is called with state already set to %s, prov.id is null' % (
				request.session.session_key, request.session['ivr2_state']))
		else:
			logger.debug('%s: ProviderIVR_Main_New is called with state already set to %s, prov.id %s' % (
				request.session.session_key, request.session['ivr2_state'], request.session['provider_id']))
		request.session['ivr2_state'] = 'ProviderIVR_Main_New'

	logger.debug('%s: ProviderIVR_Main_New POST data is %s' % (request.session.session_key, str(request.POST)))
#	logger.debug('%s: ProviderIVR_Main_New META data is %s' % (request.session.session_key, str(request.META)))

	# check if this is the callback when call is completed (should redirect to ProviderIVR_Status)
	callEnded = _checkCallbackDuration(request)
	if callEnded:
		# we are done
		return callEnded

	# main functionality of this call
	(caller, called) = _setup_Main_callers(request)
	# set up provider_id in session
	provider_called = _getUniqueProvider(called)
	request.session['provider_id'] = provider_called.id

	# if caller has a doctorcom number, mask it
	caller_mhluser = _getMHLUser(caller)
	caller_provider = _maskProviderCaller(request, caller_mhluser)

	# set up callLog if none is defined:
	callSID = request.POST['CallSid']
	log = _getOrCreateCallLog(request, callSID, caller, called, 'OC', provider_called, caller_mhluser)
	if caller_provider:
		log.mdcom_caller = caller_provider
	log.save()

	logger.debug('%s: ProviderIVR_Main_New caller %s called %s callSid %s prov mobile %s' % (
		request.session.session_key, caller, called, callSID, provider_called.user.mobile_phone))

	if provider_called.user.mobile_phone != caller:
		request.session['ivr2_state'] = 'ProviderIVR_ForwardCall_New'
		logger.debug('%s: ProviderIVR_Main_New forwarding caller %s called %s called mobile %s' % (
			request.session.session_key, caller, called, provider_called.user.mobile_phone))
		return ProviderIVR_ForwardCall_New(request, provider_called)

	# otherwise, this is owner calling in
	log.call_source = 'VM'
	log.save()
	# check if VM config is all set up - if not, we go to ProviderIVR_Setup
	try:
		config = provider_called.vm_config.get()
	except MultipleObjectsReturned:
		raise Exception("Provider %s %s has multiple vm_config objects." % (
				provider_called.user.first_name, provider_called.user.last_name))
	except ObjectDoesNotExist:
		request.session['ivr2_state'] = 'ProviderIVR_Setup_New'
		return ProviderIVR_Setup_New(request)

	# Check to see if the PIN value exists in the configuration. Pin *should* be set through the web interface
	# or it won't be able to be set/changed as anonymous user
	if (not config.pin):
		logger.debug('%s: ProviderIVR_Main_New config pin not set - provider %s' % (
			request.session.session_key, provider_called.user.mobile_phone))
		request.session['ivr2_state'] = 'ProviderIVR_Setup_New'
		request.session.modified = True
		return ProviderIVR_Setup_New(request)

	request.session['config_id'] = config.id
	if (not 'authenticated' in request.session):
		logger.debug('%s: ProviderIVR_Main_New authenticating - provider %s' % (
			request.session.session_key, provider_called.user.mobile_phone))
		request.session['ivr2_state'] = 'ProviderIVR_Main_New'
		request.session.modified = True
		r = twilio.Response()
		return authenticateSessionNew(request, r)

	# Now, check to ensure that user voicemail configuration was completed successfully.
	if (not config.config_complete):
		logger.debug('%s: ProviderIVR_Main_New config incomplete - provider %s' % (
			request.session.session_key, provider_called.user.mobile_phone))
		request.session['ivr2_state'] = 'ProviderIVR_Setup_New'
		return ProviderIVR_Setup_New(request, provider_called)

	# everything else goes to main call tree
	request.session['ivr2_state'] = 'ProviderIVR_TreeRoot_New'
	return ProviderIVR_TreeRoot_New(request, provider_called)
Ejemplo n.º 8
0
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)
Ejemplo n.º 9
0
def ProviderIVR_Main_New(request):
    """
	initial call into provider -- Only called with new Twilio 2010 API
	initializes caller, called, provider_id, callLog and mask caller number with 
	doctorcom Number if caller has a doctorcom number
	I leave the numbers with + and country code but strip them off the number of 
	caller/called when we lookup the database for provider or mhluser
	"""
    if (not 'ivr2_state' in request.session):
        # beginning of the very first call
        request.session['ivr2_state'] = 'ProviderIVR_Main_New'
        logger.debug('%s: ProviderIVR_Main_New is initiated' %
                     (request.session.session_key))
    elif (request.session['ivr2_state']
          and (request.session['ivr2_state'] != 'ProviderIVR_Main_New')
          and (request.session['ivr2_state'] != 'ProviderIVR_TreeRoot_New')):
        # this shouldn't happen, but if it did, and we log and keep going
        if (not 'provider_id' in request.session):
            logger.debug(
                '%s: ProviderIVR_Main_New is called with state already set to %s, prov.id is null'
                % (request.session.session_key, request.session['ivr2_state']))
        else:
            logger.debug(
                '%s: ProviderIVR_Main_New is called with state already set to %s, prov.id %s'
                % (request.session.session_key, request.session['ivr2_state'],
                   request.session['provider_id']))
        request.session['ivr2_state'] = 'ProviderIVR_Main_New'

    logger.debug('%s: ProviderIVR_Main_New POST data is %s' %
                 (request.session.session_key, str(request.POST)))
    #	logger.debug('%s: ProviderIVR_Main_New META data is %s' % (request.session.session_key, str(request.META)))

    # check if this is the callback when call is completed (should redirect to ProviderIVR_Status)
    callEnded = _checkCallbackDuration(request)
    if callEnded:
        # we are done
        return callEnded

    # main functionality of this call
    (caller, called) = _setup_Main_callers(request)
    # set up provider_id in session
    provider_called = _getUniqueProvider(called)
    request.session['provider_id'] = provider_called.id

    # if caller has a doctorcom number, mask it
    caller_mhluser = _getMHLUser(caller)
    caller_provider = _maskProviderCaller(request, caller_mhluser)

    # set up callLog if none is defined:
    callSID = request.POST['CallSid']
    log = _getOrCreateCallLog(request, callSID, caller, called, 'OC',
                              provider_called, caller_mhluser)
    if caller_provider:
        log.mdcom_caller = caller_provider
    log.save()

    logger.debug(
        '%s: ProviderIVR_Main_New caller %s called %s callSid %s prov mobile %s'
        % (request.session.session_key, caller, called, callSID,
           provider_called.user.mobile_phone))

    if provider_called.user.mobile_phone != caller:
        request.session['ivr2_state'] = 'ProviderIVR_ForwardCall_New'
        logger.debug(
            '%s: ProviderIVR_Main_New forwarding caller %s called %s called mobile %s'
            % (request.session.session_key, caller, called,
               provider_called.user.mobile_phone))
        return ProviderIVR_ForwardCall_New(request, provider_called)

    # otherwise, this is owner calling in
    log.call_source = 'VM'
    log.save()
    # check if VM config is all set up - if not, we go to ProviderIVR_Setup
    try:
        config = provider_called.vm_config.get()
    except MultipleObjectsReturned:
        raise Exception(
            "Provider %s %s has multiple vm_config objects." %
            (provider_called.user.first_name, provider_called.user.last_name))
    except ObjectDoesNotExist:
        request.session['ivr2_state'] = 'ProviderIVR_Setup_New'
        return ProviderIVR_Setup_New(request)

    # Check to see if the PIN value exists in the configuration. Pin *should* be set through the web interface
    # or it won't be able to be set/changed as anonymous user
    if (not config.pin):
        logger.debug(
            '%s: ProviderIVR_Main_New config pin not set - provider %s' %
            (request.session.session_key, provider_called.user.mobile_phone))
        request.session['ivr2_state'] = 'ProviderIVR_Setup_New'
        request.session.modified = True
        return ProviderIVR_Setup_New(request)

    request.session['config_id'] = config.id
    if (not 'authenticated' in request.session):
        logger.debug(
            '%s: ProviderIVR_Main_New authenticating - provider %s' %
            (request.session.session_key, provider_called.user.mobile_phone))
        request.session['ivr2_state'] = 'ProviderIVR_Main_New'
        request.session.modified = True
        r = twilio.Response()
        return authenticateSessionNew(request, r)

    # Now, check to ensure that user voicemail configuration was completed successfully.
    if (not config.config_complete):
        logger.debug(
            '%s: ProviderIVR_Main_New config incomplete - provider %s' %
            (request.session.session_key, provider_called.user.mobile_phone))
        request.session['ivr2_state'] = 'ProviderIVR_Setup_New'
        return ProviderIVR_Setup_New(request, provider_called)

    # everything else goes to main call tree
    request.session['ivr2_state'] = 'ProviderIVR_TreeRoot_New'
    return ProviderIVR_TreeRoot_New(request, provider_called)
Ejemplo n.º 10
0
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)
Ejemplo n.º 11
0
def PracticeIVR_Setup_New(request):
	"""
	This function is heavily dependent upon request.session; Twilio is kind
	enough to keep session cookies for us.
	sets up doctor com answering service practice open/closed greetings and pin
	"""
	assert(request.session['practice_id'])
	assert(request.session['ivr2_state'] == 'PracticeIVR_Setup_New')
	_checkCallbackDuration(request)
	logger.debug('%s: PracticeIVR_Setup_New POST data is %s' % (
		request.session.session_key, str(request.POST)))
	logger.debug('%s: PracticeIVR_Setup_New state %s practice %s' % (
		request.session.session_key, request.session['ivr2_state'], request.session['practice_id']))

	# TODO - check if we need to create event for this
	if ('ivr2_sub_state' not in request.session):
		request.session['ivr2_sub_state'] = 'PracticeIVR_Setup_Start'
	else:
		logger.debug('%s: PracticeIVR_Setup_New sub_state %s' % (
			request.session.session_key, request.session['ivr2_sub_state']))
	if (request.session['ivr2_sub_state'] == 'PracticeIVR_Setup_Start'):
		# Okay, this is the first time this function is being executed for this call.
		request.session['ivr2_sub_state'] = 'PracticeIVR_Setup_1'
		#will need to Practice Location and see if this needs set up and values that are there already
		r = twilio.Response()
		r.append(twilio.Pause())  # one second pause keeps the first words from getting cut off.
		request.session['ivr2_prompt_str'] = "Welcome to your voicemail account. It looks like some setup is needed. \
Let's get started. First, we need to set up your pin number."
		return changePinNew(request, r)

	elif (request.session['ivr2_sub_state'] == 'PracticeIVR_Setup_1'):  # Record name
		request.session['ivr2_sub_state'] = 'PracticeIVR_Setup_2'
		return changeNameNew(request, _('Now, we need to record your office name.'))

	elif (request.session['ivr2_sub_state'] == 'PracticeIVR_Setup_2'):
		# Record a greeting for closed office
		request.session['ivr2_sub_state'] = 'PracticeIVR_Setup_3'
#		request.session['ivr2_setup_stage'] = 3  # deprecated
		return changeGreetingNew(request, _('Next, we need to set up your answering service '
			'greeting. This will be played when the office is closed.'))

	elif (request.session['ivr2_sub_state'] == 'PracticeIVR_Setup_3'):  # Record a greeting for open
		request.session['ivr2_sub_state'] = 'PracticeIVR_Setup_4'
#		request.session['ivr2_setup_stage'] = 4  # deprecated
		return changeGreetingNew(request, _('Finally, we need to set up a greeting that '
			'will be played when the office is open.'))

	elif (request.session['ivr2_sub_state'] == 'PracticeIVR_Setup_4'):  # Configuration complete!
		#store new information in Practice Locations
		del request.session['ivr2_sub_state']
		request.session['ivr2_state'] = 'PracticeIVR_TreeRoot_New'
		practice = PracticeLocation.objects.get(id=request.session['practice_id'])
		practice.config_complete = True
		practice.save()
		# we don't need the welcome msg anymore
		if ('ivr2_prompt_str' in request.session):
			del request.session['ivr2_prompt_str']

		r = twilio.Response()
		r.append(tts(_('Your voice mail account is now set up. You may hang up now.')))
		r.append(twilio.Redirect(reverse('PracticeIVR_TreeRoot_New')))
		return HttpResponse(str(r), mimetype=settings.TWILIO_RESPONSE_MIMETYPE)

	else:
		# should not get here with unknown state - log state and return to main; or throw exception?
		logger.debug('%s: PracticeIVR_Setup_New has unhandled state set to %s' % (
			request.session.session_key, request.session['ivr2_state']))
		request.session['ivr2_state'] = 'PracticeIVR_Main_New'
		return PracticeIVR_Main_New(request)
Ejemplo n.º 12
0
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)
Ejemplo n.º 13
0
def PracticeIVR_Main_New(request):
	"""
	entry point when call comes in to doctor.com number associated with Practice
	"""
	logger.debug('%s: PracticeIVR_Main_New POST data is %s' % (request.session.session_key, str(request.POST)))
#	logger.debug('%s: PracticeIVR_Main_New META data is %s' % (request.session.session_key, str(request.META)))

	# if call ended, we don't process anymore; just get call duration
	callEnded = _checkCallbackDuration(request)
	if callEnded:
		# we are done
		return callEnded
	request.session['answering_service'] = 'yes'

	(caller, called) = _setup_Main_callers(request)
	# set up practice_id in session
	try:
		practice = PracticeLocation.objects.get(mdcom_phone=called)
		can_have_answering_service = practice.get_setting_attr('can_have_answering_service')
		if (not can_have_answering_service):
			r = twilio.Response()
			r.append(tts(_("I'm sorry, answering service is not available. Good bye.")))
			return HttpResponse(str(r), mimetype=settings.TWILIO_RESPONSE_MIMETYPE)
	except MultipleObjectsReturned:
		raise Exception(_('Multiple Practice Locations have mdcom_phone %s') % (called,))
	except ObjectDoesNotExist:
		raise Exception(_('No Practice Location have mdcom_phone %s') % (called,))

	# if caller is an existing user with doctorcom number, mask the caller number with doctorcom number
	caller_mhluser = _getMHLUser(caller)
	caller_provider = _maskProviderCaller(request, caller_mhluser)
	logger.debug('%s: PracticeIVR_Main_New practice %s caller %s provider %s' % (
		request.session.session_key, practice, caller_mhluser, caller_provider))

	# set up callLog if none is defined:
	callSID = request.POST['CallSid']
	log = _getOrCreateCallLog(request, callSID, caller, called, 'OC', practice, caller_mhluser)
	if caller_provider:
		log.mdcom_caller = caller_provider
	log.save()

	# setup session variables needed
	# request.session['practice'] = practice #removed, look up practice by id as needed, do not store objects in the session
	request.session['practice_id'] = practice.id
#	request.session['callgroup_id'] = practice.call_group.id
	if (practice.uses_original_answering_serice()):
		request.session['callgroup_id'] = practice.call_group.id  # ONLY for V 1 groups, for V2 determine based on user selection later
	request.session['practice_phone'] = practice.practice_phone
	request.session['ivr2_only_callbacknumber'] = False
	# done with initialization

############################################################################
	# see if this is office manager calling, if yes - goto set up
	# NOTE: compare phone numbers without country code if from the database vs. with country code if from twilio parameters
	# TO DO - MANAGERS CELL ALSO NEED TO BE ADDED
	if (request.session['practice_phone'] == caller
		or practice.accessnumber_set.filter(number=caller)):

	# Great, now we know that this is the owner calling in. First up, check to
	# see if the user has a configuration file and that they've completed setup
	#it is stored with practice location, for now act like first time

	# Now, check to ensure that user voicemail configuration was completed successfully.
		if (not practice.config_complete):
			request.session['ivr2_state'] = 'PracticeIVR_Setup_New'
			request.session.modified = True
			logger.debug('%s: PracticeIVR_Main_New need setup for practice %s' % (
				request.session.session_key, practice))
			return PracticeIVR_Setup_New(request)

	#config was complete, but call is made, ask if want to change settings
		else:
			#make sure they have pin for setting
			logger.debug('%s: PracticeIVR_Main_New setup complete; need auth for practice %s' % (
				request.session.session_key, practice))
			if (not 'authenticated' in request.session):
				request.session['ivr2_state'] = 'PracticeIVR_TreeRoot_New'
				request.session.modified = True
				r = twilio.Response()
				return authenticateSessionNew(request, r)

			request.session['ivr2_state'] = 'PracticeIVR_TreeRoot_New'
			request.session.modified = True
			logger.debug('%s: PracticeIVR_Main_New setup complete; need auth for practice %s' % (
				request.session.session_key, practice))
			return PracticeIVR_TreeRoot_New(request)

############################################################################
	#phone call from outside called, they want to call answering service
	#lets see if we open/close/or lunch - based on that we decide on call tree
	#get current time in timezone of our practice, use gmt and then make it into local,
	#calltime_local is the time we use.

	gmttz = timezone('GMT')
	mytz = timezone(practice.time_zone)
	calltime_gmt = datetime.now(gmttz)
	calltime_local = calltime_gmt.astimezone(mytz)

	request.session['calltime_local_string'] = calltime_local.strftime("%Y-%m-%d %H:%M:%S")
	request.session['calltime_local'] = calltime_local
	return PracticeIVR_CallerResponse_New(request)  # both old and new way