def on_session_heartbeat(self, event):
"""Capture every heartbeat event in a session and post info
"""
params = {}
answer_seconds_since_epoch = float(event['Caller-Channel-Answered-Time'])/1000000
# using UTC here .. make sure FS is using UTC also
params['AnsweredTime'] = str(answer_seconds_since_epoch)
heartbeat_seconds_since_epoch = float(event['Event-Date-Timestamp'])/1000000
# using UTC here .. make sure FS is using UTC also
params['HeartbeatTime'] = str(heartbeat_seconds_since_epoch)
params['ElapsedTime'] = str(heartbeat_seconds_since_epoch - answer_seconds_since_epoch)
params['To'] = event['Caller-Destination-Number'].lstrip('+')
params['From'] = event['Caller-Caller-ID-Number'].lstrip('+')
params['CallUUID'] = event['Unique-ID']
params['Direction'] = event['Call-Direction']
forwarded_from = get_substring(':', '@',
event['variable_sip_h_Diversion'])
if forwarded_from:
params['ForwardedFrom'] = forwarded_from.lstrip('+')
if event['Channel-State'] == 'CS_EXECUTE':
params['CallStatus'] = 'in-progress'
# RequestUUID through which this call was initiated if outbound
request_uuid = event['variable_plivo_request_uuid']
if request_uuid:
params['RequestUUID'] = request_uuid
self.log.debug("Got Session Heartbeat from Freeswitch: %s" % params)
if self.call_heartbeat_url:
self.log.debug("Sending heartbeat to callback: %s" % self.call_heartbeat_url)
spawn_raw(self.send_to_url, self.call_heartbeat_url, params)
def on_session_heartbeat(self, event):
"""Capture every heartbeat event in a session and post info
"""
params = {}
answer_seconds_since_epoch = float(
event['Caller-Channel-Answered-Time']) / 1000000
# using UTC here .. make sure FS is using UTC also
params['AnsweredTime'] = str(answer_seconds_since_epoch)
heartbeat_seconds_since_epoch = float(
event['Event-Date-Timestamp']) / 1000000
# using UTC here .. make sure FS is using UTC also
params['HeartbeatTime'] = str(heartbeat_seconds_since_epoch)
params['ElapsedTime'] = str(heartbeat_seconds_since_epoch -
answer_seconds_since_epoch)
called_num = event['variable_plivo_destination_number']
if not called_num or called_num == '_undef_':
called_num = event['Caller-Destination-Number'] or ''
called_num = called_num.lstrip('+')
params['To'] = called_num
params['From'] = event['Caller-Caller-ID-Number'].lstrip('+')
params['CallUUID'] = event['Unique-ID']
params['Direction'] = event['Call-Direction']
forwarded_from = get_substring(':', '@',
event['variable_sip_h_Diversion'])
if forwarded_from:
params['ForwardedFrom'] = forwarded_from.lstrip('+')
if event['Channel-State'] == 'CS_EXECUTE':
params['CallStatus'] = 'in-progress'
# RequestUUID through which this call was initiated if outbound
request_uuid = event['variable_plivo_request_uuid']
if request_uuid:
params['RequestUUID'] = request_uuid
accountsid = event['variable_plivo_accountsid']
if accountsid:
params['AccountSID'] = accountsid
self.log.debug("Got Session Heartbeat from Freeswitch: %s" % params)
if self.get_server().call_heartbeat_url:
self.log.debug("Sending heartbeat to callback: %s" %
self.get_server().call_heartbeat_url)
spawn_raw(self.send_to_url,
self.get_server().call_heartbeat_url, params)
def on_session_heartbeat(self, event):
"""Capture every heartbeat event in a session and post info
"""
params = {}
answer_seconds_since_epoch = float(event["Caller-Channel-Answered-Time"]) / 1000000
# using UTC here .. make sure FS is using UTC also
params["AnsweredTime"] = str(answer_seconds_since_epoch)
heartbeat_seconds_since_epoch = float(event["Event-Date-Timestamp"]) / 1000000
# using UTC here .. make sure FS is using UTC also
params["HeartbeatTime"] = str(heartbeat_seconds_since_epoch)
params["ElapsedTime"] = str(heartbeat_seconds_since_epoch - answer_seconds_since_epoch)
called_num = event["variable_plivo_destination_number"]
if not called_num or called_num == "_undef_":
called_num = event["Caller-Destination-Number"] or ""
called_num = called_num.lstrip("+")
params["To"] = called_num
params["From"] = event["Caller-Caller-ID-Number"].lstrip("+")
params["CallUUID"] = event["Unique-ID"]
params["Direction"] = event["Call-Direction"]
forwarded_from = get_substring(":", "@", event["variable_sip_h_Diversion"])
if forwarded_from:
params["ForwardedFrom"] = forwarded_from.lstrip("+")
if event["Channel-State"] == "CS_EXECUTE":
params["CallStatus"] = "in-progress"
# RequestUUID through which this call was initiated if outbound
request_uuid = event["variable_plivo_request_uuid"]
if request_uuid:
params["RequestUUID"] = request_uuid
accountsid = event["variable_plivo_accountsid"]
if accountsid:
params["AccountSID"] = accountsid
self.log.debug("Got Session Heartbeat from Freeswitch: %s" % params)
if self.get_server().call_heartbeat_url:
self.log.debug("Sending heartbeat to callback: %s" % self.get_server().call_heartbeat_url)
spawn_raw(self.send_to_url, self.get_server().call_heartbeat_url, params)
def _run(self):
self.connect()
self.resume()
# Linger to get all remaining events before closing
self.linger()
self.myevents()
self.divert_events('on')
if self._is_eventjson:
self.eventjson('CUSTOM conference::maintenance plivo::dial')
else:
self.eventplain('CUSTOM conference::maintenance plivo::dial')
# Set plivo app flag
self.set('plivo_app=true')
# Don't hangup after bridge
self.set('hangup_after_bridge=false')
channel = self.get_channel()
self.call_uuid = self.get_channel_unique_id()
called_no = channel.get_header("variable_plivo_destination_number")
if not called_no or called_no == '_undef_':
called_no = channel.get_header('Caller-Destination-Number')
called_no = called_no or ''
from_no = channel.get_header('Caller-Caller-ID-Number') or ''
from_caller_name = channel.get_header('Caller-Caller-ID-Name') or ''
# Set To to Session Params
self.session_params['To'] = called_no.lstrip('+')
# Set From to Session Params
self.session_params['From'] = from_no.lstrip('+')
# Set CallerName to Session Params
self.session_params['CallerName'] = from_caller_name
# Set CallUUID to Session Params
self.session_params['CallUUID'] = self.call_uuid
# Set Direction to Session Params
self.session_params['Direction'] = channel.get_header('Call-Direction')
aleg_uuid = ''
aleg_request_uuid = ''
forwarded_from = get_substring(':', '@',
channel.get_header('variable_sip_h_Diversion'))
if self.session_params['Direction'] == 'outbound':
# Look for variables in channel headers
aleg_uuid = channel.get_header('Caller-Unique-ID')
aleg_request_uuid = channel.get_header('variable_plivo_request_uuid')
# Look for target url in order below :
# get plivo_transfer_url from channel var
# get plivo_answer_url from channel var
xfer_url = channel.get_header('variable_plivo_transfer_url')
answer_url = channel.get_header('variable_plivo_answer_url')
if xfer_url:
self.target_url = xfer_url
self.log.info("Using TransferUrl %s" % self.target_url)
elif answer_url:
self.target_url = answer_url
self.log.info("Using AnswerUrl %s" % self.target_url)
else:
self.log.error('Aborting -- No Call Url found !')
if not self.has_hangup():
self.hangup()
raise RESTHangup()
return
# Look for a sched_hangup_id
sched_hangup_id = channel.get_header('variable_plivo_sched_hangup_id')
# Don't post hangup in outbound direction
# because it is handled by inboundsocket
self.default_hangup_url = None
self.hangup_url = None
# Set CallStatus to Session Params
self.session_params['CallStatus'] = 'in-progress'
accountsid = channel.get_header("variable_plivo_accountsid")
if accountsid:
self.session_params['AccountSID'] = accountsid
else:
# Look for target url in order below :
# get plivo_transfer_url from channel var
# get plivo_answer_url from channel var
# get default answer_url from config
xfer_url = self.get_var('plivo_transfer_url')
answer_url = self.get_var('plivo_answer_url')
if xfer_url:
self.target_url = xfer_url
self.log.info("Using TransferUrl %s" % self.target_url)
elif answer_url:
self.target_url = answer_url
self.log.info("Using AnswerUrl %s" % self.target_url)
elif self.default_answer_url:
self.target_url = self.default_answer_url
self.log.info("Using DefaultAnswerUrl %s" % self.target_url)
else:
self.log.error('Aborting -- No Call Url found !')
if not self.has_hangup():
self.hangup()
raise RESTHangup()
return
# Look for a sched_hangup_id
sched_hangup_id = self.get_var('plivo_sched_hangup_id')
# Set CallStatus to Session Params
self.session_params['CallStatus'] = 'ringing'
if not sched_hangup_id:
sched_hangup_id = ''
# Add more Session Params if present
if aleg_uuid:
self.session_params['ALegUUID'] = aleg_uuid
if aleg_request_uuid:
self.session_params['ALegRequestUUID'] = aleg_request_uuid
if sched_hangup_id:
self.session_params['ScheduledHangupId'] = sched_hangup_id
if forwarded_from:
self.session_params['ForwardedFrom'] = forwarded_from.lstrip('+')
# Remove sched_hangup_id from channel vars
if sched_hangup_id:
self.unset('plivo_sched_hangup_id')
# Run application
self.log.info('Processing Call')
try:
self.process_call()
except RESTHangup:
self.log.warn('Channel has hung up, breaking Processing Call')
except Exception, e:
self.log.error('Processing Call Failure !')
# If error occurs during xml parsing
# log exception and break
self.log.error(str(e))
[ self.log.error(line) for line in \
traceback.format_exc().splitlines() ]
def _run(self):
self.connect()
self.resume()
# Linger to get all remaining events before closing
self.linger()
self.myevents()
self.divert_events('on')
if self._is_eventjson:
self.eventjson('CUSTOM conference::maintenance plivo::dial')
else:
self.eventplain('CUSTOM conference::maintenance plivo::dial')
# Set plivo app flag
self.set('plivo_app=true')
# Don't hangup after bridge
self.set('hangup_after_bridge=false')
channel = self.get_channel()
self.call_uuid = self.get_channel_unique_id()
# Set CallerName to Session Params
self.session_params['CallerName'] = channel.get_header(
'Caller-Caller-ID-Name') or ''
# Set CallUUID to Session Params
self.session_params['CallUUID'] = self.call_uuid
# Set Direction to Session Params
self.session_params['Direction'] = channel.get_header('Call-Direction')
aleg_uuid = ''
aleg_request_uuid = ''
forwarded_from = get_substring(
':', '@', channel.get_header('variable_sip_h_Diversion'))
# Case Outbound
if self.session_params['Direction'] == 'outbound':
# Set To / From
called_no = channel.get_header("variable_plivo_to")
if not called_no or called_no == '_undef_':
called_no = channel.get_header('Caller-Destination-Number')
called_no = called_no or ''
from_no = channel.get_header("variable_plivo_from")
if not from_no or from_no == '_undef_':
from_no = channel.get_header('Caller-Caller-ID-Number') or ''
# Set To to Session Params
self.session_params['To'] = called_no.lstrip('+')
# Set From to Session Params
self.session_params['From'] = from_no.lstrip('+')
# Look for variables in channel headers
aleg_uuid = channel.get_header('Caller-Unique-ID')
aleg_request_uuid = channel.get_header(
'variable_plivo_request_uuid')
# Look for target url in order below :
# get plivo_transfer_url from channel var
# get plivo_answer_url from channel var
xfer_url = channel.get_header('variable_plivo_transfer_url')
answer_url = channel.get_header('variable_plivo_answer_url')
if xfer_url:
self.target_url = xfer_url
self.log.info("Using TransferUrl %s" % self.target_url)
elif answer_url:
self.target_url = answer_url
self.log.info("Using AnswerUrl %s" % self.target_url)
else:
self.log.error('Aborting -- No Call Url found !')
if not self.has_hangup():
self.hangup()
raise RESTHangup()
return
# Look for a sched_hangup_id
sched_hangup_id = channel.get_header(
'variable_plivo_sched_hangup_id')
# Don't post hangup in outbound direction
# because it is handled by inboundsocket
self.default_hangup_url = None
self.hangup_url = None
# Set CallStatus to Session Params
self.session_params['CallStatus'] = 'in-progress'
# Set answered flag to true in case outbound call
self.answered = True
accountsid = channel.get_header("variable_plivo_accountsid")
if accountsid:
self.session_params['AccountSID'] = accountsid
# Case Inbound
else:
# Set To / From
called_no = channel.get_header("variable_plivo_destination_number")
if not called_no or called_no == '_undef_':
called_no = channel.get_header('Caller-Destination-Number')
called_no = called_no or ''
from_no = channel.get_header('Caller-Caller-ID-Number') or ''
# Set To to Session Params
self.session_params['To'] = called_no.lstrip('+')
# Set From to Session Params
self.session_params['From'] = from_no.lstrip('+')
# Look for target url in order below :
# get plivo_transfer_url from channel var
# get plivo_answer_url from channel var
# get default answer_url from config
xfer_url = self.get_var('plivo_transfer_url')
answer_url = self.get_var('plivo_answer_url')
if xfer_url:
self.target_url = xfer_url
self.log.info("Using TransferUrl %s" % self.target_url)
elif answer_url:
self.target_url = answer_url
self.log.info("Using AnswerUrl %s" % self.target_url)
elif self.default_answer_url:
self.target_url = self.default_answer_url
self.log.info("Using DefaultAnswerUrl %s" % self.target_url)
else:
self.log.error('Aborting -- No Call Url found !')
if not self.has_hangup():
self.hangup()
raise RESTHangup()
return
# Look for a sched_hangup_id
sched_hangup_id = self.get_var('plivo_sched_hangup_id')
# Set CallStatus to Session Params
self.session_params['CallStatus'] = 'ringing'
if not sched_hangup_id:
sched_hangup_id = ''
# Add more Session Params if present
if aleg_uuid:
self.session_params['ALegUUID'] = aleg_uuid
if aleg_request_uuid:
self.session_params['ALegRequestUUID'] = aleg_request_uuid
if sched_hangup_id:
self.session_params['ScheduledHangupId'] = sched_hangup_id
if forwarded_from:
self.session_params['ForwardedFrom'] = forwarded_from.lstrip('+')
# Remove sched_hangup_id from channel vars
if sched_hangup_id:
self.unset('plivo_sched_hangup_id')
# Run application
self.log.info('Processing Call')
try:
self.process_call()
except RESTHangup:
self.log.warn('Channel has hung up, breaking Processing Call')
except Exception, e:
self.log.error('Processing Call Failure !')
# If error occurs during xml parsing
# log exception and break
self.log.error(str(e))
[ self.log.error(line) for line in \
traceback.format_exc().splitlines() ]
def set_hangup_complete(self, request_uuid, call_uuid, reason, event, hangup_url):
params = {}
# add extra params
params = self.get_extra_fs_vars(event)
# case incoming call
if not request_uuid:
self.log.info("Hangup for Incoming CallUUID %s Completed, HangupCause %s" \
% (call_uuid, reason))
# get hangup url
hangup_url = event['variable_plivo_hangup_url']
if hangup_url:
self.log.debug("Using HangupUrl for CallUUID %s" \
% call_uuid)
else:
if self.get_server().default_hangup_url:
hangup_url = self.get_server().default_hangup_url
self.log.debug("Using HangupUrl from DefaultHangupUrl for CallUUID %s" \
% call_uuid)
elif event['variable_plivo_answer_url']:
hangup_url = event['variable_plivo_answer_url']
self.log.debug("Using HangupUrl from AnswerUrl for CallUUID %s" \
% call_uuid)
elif self.get_server().default_answer_url:
hangup_url = self.get_server().default_answer_url
self.log.debug("Using HangupUrl from DefaultAnswerUrl for CallUUID %s" \
% call_uuid)
if not hangup_url:
self.log.debug("No HangupUrl for Incoming CallUUID %s" % call_uuid)
return
called_num = event['variable_plivo_destination_number']
if not called_num or called_num == '_undef_':
called_num = event['Caller-Destination-Number'] or ''
called_num = called_num.lstrip('+')
caller_num = event['Caller-Caller-ID-Number']
direction = event['Call-Direction']
# case outgoing call, add params
else:
self.log.info("Hangup for Outgoing CallUUID %s Completed, HangupCause %s, RequestUUID %s"
% (call_uuid, reason, request_uuid))
try:
call_req = self.call_requests[request_uuid]
called_num = call_req.to.lstrip('+')
caller_num = call_req._from
if call_req._accountsid:
params['AccountSID'] = call_req._accountsid
direction = "outbound"
self.call_requests[request_uuid] = None
del self.call_requests[request_uuid]
except (KeyError, AttributeError):
called_num = ''
caller_num = ''
direction = "outbound"
self.log.debug("Call Cleaned up for RequestUUID %s" % request_uuid)
if not hangup_url:
self.log.debug("No HangupUrl for Outgoing Call %s, RequestUUID %s" % (call_uuid, request_uuid))
return
forwarded_from = get_substring(':', '@', event['variable_sip_h_Diversion'])
aleg_uuid = event['Caller-Unique-ID']
aleg_request_uuid = event['variable_plivo_request_uuid']
sched_hangup_id = event['variable_plivo_sched_hangup_id']
params['RequestUUID'] = request_uuid
if forwarded_from:
params['ForwardedFrom'] = forwarded_from.lstrip('+')
if aleg_uuid:
params['ALegUUID'] = aleg_uuid
if aleg_request_uuid:
params['ALegRequestUUID'] = aleg_request_uuid
if sched_hangup_id:
params['ScheduledHangupId'] = sched_hangup_id
# if hangup url, handle http request
if hangup_url:
sip_uri = event['variable_plivo_sip_transfer_uri'] or ''
if sip_uri:
params['SIPTransfer'] = 'true'
params['SIPTransferURI'] = sip_uri
params['CallUUID'] = call_uuid or ''
params['HangupCause'] = reason
params['To'] = called_num or ''
params['From'] = caller_num or ''
params['Direction'] = direction or ''
params['CallStatus'] = 'completed'
spawn_raw(self.send_to_url, hangup_url, params)
def set_hangup_complete(self, request_uuid, call_uuid, reason, event, hangup_url):
params = {}
# add extra params
params = self.get_extra_fs_vars(event)
# case incoming call
if not request_uuid:
self.log.info("Hangup for Incoming CallUUID %s Completed, HangupCause %s" \
% (call_uuid, reason))
# get hangup url
hangup_url = event['variable_plivo_hangup_url']
if hangup_url:
self.log.debug("Using HangupUrl for CallUUID %s" \
% call_uuid)
else:
if self.get_server().default_hangup_url:
hangup_url = self.get_server().default_hangup_url
self.log.debug("Using HangupUrl from DefaultHangupUrl for CallUUID %s" \
% call_uuid)
elif event['variable_plivo_answer_url']:
hangup_url = event['variable_plivo_answer_url']
self.log.debug("Using HangupUrl from AnswerUrl for CallUUID %s" \
% call_uuid)
elif self.get_server().default_answer_url:
hangup_url = self.get_server().default_answer_url
self.log.debug("Using HangupUrl from DefaultAnswerUrl for CallUUID %s" \
% call_uuid)
if not hangup_url:
self.log.debug("No HangupUrl for Incoming CallUUID %s" % call_uuid)
return
called_num = event['variable_plivo_destination_number']
if not called_num or called_num == '_undef_':
called_num = event['Caller-Destination-Number'] or ''
called_num = called_num.lstrip('+')
caller_num = event['Caller-Caller-ID-Number']
direction = event['Call-Direction']
# case outgoing call, add params
else:
self.log.info("Hangup for Outgoing CallUUID %s Completed, HangupCause %s, RequestUUID %s"
% (call_uuid, reason, request_uuid))
try:
call_req = self.call_requests[request_uuid]
called_num = call_req.to.lstrip('+')
caller_num = call_req._from
if call_req._accountsid:
params['AccountSID'] = call_req._accountsid
direction = "outbound"
self.call_requests[request_uuid] = None
del self.call_requests[request_uuid]
except (KeyError, AttributeError):
called_num = ''
caller_num = ''
direction = "outbound"
self.log.debug("Call Cleaned up for RequestUUID %s" % request_uuid)
if not hangup_url:
self.log.debug("No HangupUrl for Outgoing Call %s, RequestUUID %s" % (call_uuid, request_uuid))
return
forwarded_from = get_substring(':', '@', event['variable_sip_h_Diversion'])
aleg_uuid = event['Caller-Unique-ID']
aleg_request_uuid = event['variable_plivo_request_uuid']
sched_hangup_id = event['variable_plivo_sched_hangup_id']
params['RequestUUID'] = request_uuid
if forwarded_from:
params['ForwardedFrom'] = forwarded_from.lstrip('+')
if aleg_uuid:
params['ALegUUID'] = aleg_uuid
if aleg_request_uuid:
params['ALegRequestUUID'] = aleg_request_uuid
if sched_hangup_id:
params['ScheduledHangupId'] = sched_hangup_id
# if hangup url, handle http request
if hangup_url:
sip_uri = event['variable_plivo_sip_transfer_uri'] or ''
if sip_uri:
params['SIPTransfer'] = 'true'
params['SIPTransferURI'] = sip_uri
params['CallUUID'] = call_uuid or ''
params['HangupCause'] = reason
params['To'] = called_num or ''
params['From'] = caller_num or ''
params['Direction'] = direction or ''
params['CallStatus'] = 'completed'
spawn_raw(self.send_to_url, hangup_url, params)
def _run(self):
self.connect()
# self.filter('Event-Name /(CHANNEL_HANGUP|CHANNEL_EXECUTE_COMPLETE|CUSTOM)/')
self.resume()
# Linger to get all remaining events before closing
self.linger()
self.myevents()
if self._is_eventjson:
self.eventjson("DTMF CUSTOM conference::maintenance")
else:
self.eventplain("DTMF CUSTOM conference::maintenance")
# Set plivo app flag
self.set("plivo_app=true")
# Don't hangup after bridge
self.set("hangup_after_bridge=false")
channel = self.get_channel()
self.call_uuid = self.get_channel_unique_id()
called_no = channel.get_header("Caller-Destination-Number")
from_no = channel.get_header("Caller-Caller-ID-Number")
# Set To to Session Params
self.session_params["To"] = called_no.lstrip("+")
# Set From to Session Params
self.session_params["From"] = from_no.lstrip("+")
# Set CallUUID to Session Params
self.session_params["CallUUID"] = self.call_uuid
# Set Direction to Session Params
self.session_params["Direction"] = channel.get_header("Call-Direction")
aleg_uuid = ""
aleg_request_uuid = ""
forwarded_from = get_substring(":", "@", channel.get_header("variable_sip_h_Diversion"))
if self.session_params["Direction"] == "outbound":
# Look for variables in channel headers
aleg_uuid = channel.get_header("Caller-Unique-ID")
aleg_request_uuid = channel.get_header("variable_plivo_request_uuid")
# Look for target url in order below :
# get plivo_transfer_url from channel var
# get plivo_answer_url from channel var
xfer_url = channel.get_header("variable_plivo_transfer_url")
answer_url = channel.get_header("variable_plivo_answer_url")
if xfer_url:
self.target_url = xfer_url
self.log.info("Using TransferUrl %s" % self.target_url)
elif answer_url:
self.target_url = answer_url
self.log.info("Using AnswerUrl %s" % self.target_url)
else:
self.log.error("Aborting -- No Call Url found !")
return
# Look for a sched_hangup_id
sched_hangup_id = channel.get_header("variable_plivo_sched_hangup_id")
# Don't post hangup in outbound direction
# because it is handled by inboundsocket
self.default_hangup_url = None
self.hangup_url = None
self.log.info("HangupUrl not set for outbound call")
# Set CallStatus to Session Params
self.session_params["CallStatus"] = "in-progress"
else:
# Look for target url in order below :
# get plivo_transfer_url from channel var
# get plivo_answer_url from channel var
# get default answer_url from config
xfer_url = self.get_var("plivo_transfer_url")
answer_url = self.get_var("plivo_answer_url")
if xfer_url:
self.target_url = xfer_url
self.log.info("Using TransferUrl %s" % self.target_url)
elif answer_url:
self.target_url = answer_url
self.log.info("Using AnswerUrl %s" % self.target_url)
elif self.default_answer_url:
self.target_url = self.default_answer_url
self.log.info("Using DefaultAnswerUrl %s" % self.target_url)
else:
self.log.error("Aborting -- No Call Url found !")
return
# Look for a sched_hangup_id
sched_hangup_id = self.get_var("plivo_sched_hangup_id")
# Look for hangup_url in order below :
# get plivo_hangup_url from channel var if found
# get default_hangup_url from config if found
# get plivo_answer_url from channel var if found
# get default_answer_url from config if found
hangup_url = self.get_var("plivo_hangup_url")
if hangup_url:
self.hangup_url = hangup_url
self.log.info("Using HangupUrl %s from plivo_hangup_url channel var" % self.hangup_url)
elif self.default_hangup_url:
self.hangup_url = self.default_hangup_url
self.log.info("Using HangupUrl %s from hangup url in config" % self.hangup_url)
elif answer_url:
self.hangup_url = answer_url
self.log.info("Using HangupUrl %s from plivo_answer_url channel var" % self.hangup_url)
elif self.default_answer_url:
self.hangup_url = self.default_answer_url
self.log.info("Using HangupUrl %s from answer url in config" % self.hangup_url)
# Set CallStatus to Session Params
self.session_params["CallStatus"] = "ringing"
if not sched_hangup_id:
sched_hangup_id = ""
# Add more Session Params if present
if aleg_uuid:
self.session_params["ALegUUID"] = aleg_uuid
if aleg_request_uuid:
self.session_params["ALegRequestUUID"] = aleg_request_uuid
if sched_hangup_id:
self.session_params["ScheduledHangupId"] = sched_hangup_id
if forwarded_from:
self.session_params["ForwardedFrom"] = forwarded_from.lstrip("+")
self.get_extra_fs_vars()
# Remove sched_hangup_id from channel vars
if sched_hangup_id:
self.unset("plivo_sched_hangup_id")
# Run application
self.log.info("Processing Call")
try:
self.process_call()
except RESTHangup:
self.log.warn("Channel has hung up, breaking Processing Call")
except Exception, e:
self.log.error("Processing Call Failure !")
# If error occurs during xml parsing
# log exception and break
self.log.error(str(e))
[self.log.error(line) for line in traceback.format_exc().splitlines()]
def _run(self):
self.connect()
self.resume()
# Linger to get all remaining events before closing
self.linger()
self.myevents()
self.divert_events("on")
if self._is_eventjson:
self.eventjson("CUSTOM conference::maintenance plivo::dial")
else:
self.eventplain("CUSTOM conference::maintenance plivo::dial")
# Set plivo app flag
self.set("plivo_app=true")
# Don't hangup after bridge
self.set("hangup_after_bridge=false")
channel = self.get_channel()
self.call_uuid = self.get_channel_unique_id()
# Set CallerName to Session Params
self.session_params["CallerName"] = channel.get_header("Caller-Caller-ID-Name") or ""
# Set CallUUID to Session Params
self.session_params["CallUUID"] = self.call_uuid
# Set Direction to Session Params
self.session_params["Direction"] = channel.get_header("Call-Direction")
aleg_uuid = ""
aleg_request_uuid = ""
forwarded_from = get_substring(":", "@", channel.get_header("variable_sip_h_Diversion"))
# Case Outbound
if self.session_params["Direction"] == "outbound":
# Set To / From
called_no = channel.get_header("variable_plivo_to")
if not called_no or called_no == "_undef_":
called_no = channel.get_header("Caller-Destination-Number")
called_no = called_no or ""
from_no = channel.get_header("variable_plivo_from")
if not from_no or from_no == "_undef_":
from_no = channel.get_header("Caller-Caller-ID-Number") or ""
# Set To to Session Params
self.session_params["To"] = called_no.lstrip("+")
# Set From to Session Params
self.session_params["From"] = from_no.lstrip("+")
# Look for variables in channel headers
aleg_uuid = channel.get_header("Caller-Unique-ID")
aleg_request_uuid = channel.get_header("variable_plivo_request_uuid")
# Look for target url in order below :
# get plivo_transfer_url from channel var
# get plivo_answer_url from channel var
xfer_url = channel.get_header("variable_plivo_transfer_url")
answer_url = channel.get_header("variable_plivo_answer_url")
if xfer_url:
self.target_url = xfer_url
self.log.info("Using TransferUrl %s" % self.target_url)
elif answer_url:
self.target_url = answer_url
self.log.info("Using AnswerUrl %s" % self.target_url)
else:
self.log.error("Aborting -- No Call Url found !")
if not self.has_hangup():
self.hangup()
raise RESTHangup()
return
# Look for a sched_hangup_id
sched_hangup_id = channel.get_header("variable_plivo_sched_hangup_id")
# Don't post hangup in outbound direction
# because it is handled by inboundsocket
self.default_hangup_url = None
self.hangup_url = None
# Set CallStatus to Session Params
self.session_params["CallStatus"] = "in-progress"
# Set answered flag to true in case outbound call
self.answered = True
accountsid = channel.get_header("variable_plivo_accountsid")
if accountsid:
self.session_params["AccountSID"] = accountsid
# Case Inbound
else:
# Set To / From
called_no = channel.get_header("variable_plivo_destination_number")
if not called_no or called_no == "_undef_":
called_no = channel.get_header("Caller-Destination-Number")
called_no = called_no or ""
from_no = channel.get_header("Caller-Caller-ID-Number") or ""
# Set To to Session Params
self.session_params["To"] = called_no.lstrip("+")
# Set From to Session Params
self.session_params["From"] = from_no.lstrip("+")
# Look for target url in order below :
# get plivo_transfer_url from channel var
# get plivo_answer_url from channel var
# get default answer_url from config
xfer_url = self.get_var("plivo_transfer_url")
answer_url = self.get_var("plivo_answer_url")
if xfer_url:
self.target_url = xfer_url
self.log.info("Using TransferUrl %s" % self.target_url)
elif answer_url:
self.target_url = answer_url
self.log.info("Using AnswerUrl %s" % self.target_url)
elif self.default_answer_url:
self.target_url = self.default_answer_url
self.log.info("Using DefaultAnswerUrl %s" % self.target_url)
else:
self.log.error("Aborting -- No Call Url found !")
if not self.has_hangup():
self.hangup()
raise RESTHangup()
return
# Look for a sched_hangup_id
sched_hangup_id = self.get_var("plivo_sched_hangup_id")
# Set CallStatus to Session Params
self.session_params["CallStatus"] = "ringing"
if not sched_hangup_id:
sched_hangup_id = ""
# Add more Session Params if present
if aleg_uuid:
self.session_params["ALegUUID"] = aleg_uuid
if aleg_request_uuid:
self.session_params["ALegRequestUUID"] = aleg_request_uuid
if sched_hangup_id:
self.session_params["ScheduledHangupId"] = sched_hangup_id
if forwarded_from:
self.session_params["ForwardedFrom"] = forwarded_from.lstrip("+")
# Remove sched_hangup_id from channel vars
if sched_hangup_id:
self.unset("plivo_sched_hangup_id")
# Run application
self.log.info("Processing Call")
try:
self.process_call()
except RESTHangup:
self.log.warn("Channel has hung up, breaking Processing Call")
except Exception, e:
self.log.error("Processing Call Failure !")
# If error occurs during xml parsing
# log exception and break
self.log.error(str(e))
[self.log.error(line) for line in traceback.format_exc().splitlines()]
def _run(self):
self.connect()
#self.resume()
# Linger to get all remaining events before closing
self.linger()
self.myevents()
self.divert_events('on')
if self._is_eventjson:
self.eventjson('CUSTOM conference::maintenance plivo::dial')
else:
self.eventplain('CUSTOM conference::maintenance plivo::dial')
# Set plivo app flag
self.set('plivo_app=true')
# Don't hangup after bridge
self.set('hangup_after_bridge=false')
channel = self.get_channel()
self.call_uuid = self.get_channel_unique_id()
# Set CallerName to Session Params
self.session_params['CallerName'] = channel.get_header('Caller-Caller-ID-Name') or ''
# Set CallUUID to Session Params
self.session_params['CallUUID'] = self.call_uuid
# Set Direction to Session Params
self.session_params['Direction'] = channel.get_header('Call-Direction')
aleg_uuid = ''
aleg_request_uuid = ''
forwarded_from = get_substring(':', '@',
channel.get_header('variable_sip_h_Diversion'))
start_time = channel.get_header('Channel-Channel-Created-Time')
if start_time:
self.session_params['StartTime'] = start_time
answer_time = channel.get_header('Channel-Channel-Answered-Time')
if answer_time:
self.session_params['AnswerTime'] = answer_time
assimilate_xml_vars(self, channel.get_header('variable_plivo_xml_vars'))
self.domain_flags = int(channel.get_header('variable_domain_flags'))
# Case Outbound
if self.session_params['Direction'] == 'outbound':
# Set To / From
called_no = channel.get_header("variable_plivo_to")
if not called_no or called_no == '_undef_':
called_no = channel.get_header('Caller-Destination-Number')
called_no = called_no or ''
from_no = channel.get_header("variable_plivo_from")
if not from_no or from_no == '_undef_':
from_no = channel.get_header('Caller-Caller-ID-Number') or ''
# Set To to Session Params
self.session_params['To'] = called_no.lstrip('+')
# Set From to Session Params
self.session_params['From'] = from_no.lstrip('+')
# Look for variables in channel headers
aleg_uuid = channel.get_header('Caller-Unique-ID')
aleg_request_uuid = channel.get_header('variable_plivo_request_uuid')
# Look for target url in order below :
# get plivo_transfer_url from channel var
# get plivo_answer_url from channel var
plivo_config = channel.get_header('variable_plivo_config')
assimilate_plivo_config(self, plivo_config)
assimilate_ivr_transfer_params(self, channel.get_header('variable_ivr_transfer_params'))
assimilate_user_var(self, channel.get_header("variable_basix_user"))
assimilate_group_var(self, channel.get_header("variable_basix_group"))
check_transfer_failure_action(self)
domain = channel.get_header('variable_basix_domain')
domain_id, domain_name = domain.split("*")
self.session_params['DomainName'] = domain_name
self.log.info("DomainName %s" % self.session_params['DomainName'])
if self.target_url:
self.log.info("Using AnswerUrl %s" % self.target_url)
else:
self.log.error('Aborting -- No Call Url found !')
if not self.has_hangup():
self.hangup()
raise RESTHangup()
return
# Look for a sched_hangup_id
sched_hangup_id = channel.get_header('variable_plivo_sched_hangup_id')
# Don't post hangup in outbound direction
# because it is handled by inboundsocket
self.default_hangup_url = None
self.hangup_url = None
# Set CallStatus to Session Params
self.session_params['CallStatus'] = 'in-progress'
# Set answered flag to true in case outbound call
self.answered = True
accountsid = channel.get_header("variable_plivo_accountsid")
if accountsid:
self.session_params['AccountSID'] = accountsid
# Case Inbound
else:
# Set To / From
#called_no = channel.get_header("variable_plivo_destination_number")
#if not called_no or called_no == '_undef_':
# called_no = channel.get_header('Caller-Destination-Number')
#called_no = called_no or ''
called_no = channel.get_header('variable_sip_to_user')
from_no = channel.get_header('Caller-Caller-ID-Number') or ''
# Set To to Session Params
self.session_params['To'] = called_no.lstrip('+')
# Set From to Session Params
self.session_params['From'] = from_no.lstrip('+')
caller_name = self.session_params['CallerName']
plivo_config = self.get_var('plivo_config')
assimilate_plivo_config(self, plivo_config)
assimilate_ruri_params(self, channel.get_header("variable_sip_req_params"))
assimilate_ivr_transfer_params(self, channel.get_header('variable_ivr_transfer_params'))
assimilate_user_var(self, channel.get_header("variable_basix_user"))
assimilate_group_var(self, channel.get_header("variable_basix_group"))
check_transfer_failure_action(self)
if is_anonymous(caller_name):
self.session_params['Anonymous'] = 'true'
if not (self.flags & PLIVO_FLAG_RELAY_ANONYMOUS_ANI):
self.session_params['From'] = 'Anonymous'
self.session_params['CallerName'] = 'Anonymous'
else:
self.session_params['Anonymous'] = 'false'
# Look for target url in order below :
# get plivo_transfer_url from channel var
# get plivo_answer_url from channel var
# get default answer_url from config
domain = channel.get_header('variable_basix_domain')
domain_id, domain_name = domain.split("*")
self.session_params['DomainName'] = domain_name
self.log.info("DomainName %s" % self.session_params['DomainName'])
if self.target_url:
self.log.info("Using AnswerUrl %s" % self.target_url)
elif self.default_answer_url:
self.target_url = self.default_answer_url
self.log.info("Using DefaultAnswerUrl %s" % self.target_url)
else:
self.log.error('Aborting -- No Call Url found !')
if not self.has_hangup():
self.hangup()
raise RESTHangup()
return
# Look for a sched_hangup_id
sched_hangup_id = self.get_var('plivo_sched_hangup_id')
# Set CallStatus to Session Params
if channel.get_header('Caller-Channel-Answered-Time') == '0':
self.session_params['CallStatus'] = 'ringing'
else:
self.session_params['CallStatus'] = 'in-progress'
if not sched_hangup_id:
sched_hangup_id = ''
# Add more Session Params if present
if aleg_uuid:
self.session_params['ALegUUID'] = aleg_uuid
if aleg_request_uuid:
self.session_params['ALegRequestUUID'] = aleg_request_uuid
if sched_hangup_id:
self.session_params['ScheduledHangupId'] = sched_hangup_id
if forwarded_from:
self.session_params['ForwardedFrom'] = forwarded_from.lstrip('+')
# Remove sched_hangup_id from channel vars
if sched_hangup_id:
self.unset('plivo_sched_hangup_id')
# Run application
self.log.info('Processing Call')
try:
self.process_call()
except RESTHangup:
self.log.warn('Channel has hung up, breaking Processing Call')
except Exception, e:
err = str(e)
self.log.error('Processing Call Failure !')
# If error occurs during xml parsing
# log exception and break
self.log.error(err)
[ self.log.error(line) for line in \
traceback.format_exc().splitlines() ]
self.set('plivo_error=' + err)
params = {}
params['CallUUID'] = self.session_params['CallUUID']
params['CallStatus'] = 'error'
params['Error'] = err
spawn_raw(self.notify_error, self.error_url, params)
def set_hangup_complete(self, request_uuid, call_uuid, reason, event, hangup_url):
params = {}
# add extra params
params = self.get_extra_fs_vars(event)
# case incoming call
if not request_uuid:
self.log.info("Hangup for Incoming CallUUID %s Completed, HangupCause %s" % (call_uuid, reason))
# get hangup url
hangup_url = event["variable_plivo_hangup_url"]
if hangup_url:
self.log.debug("Using HangupUrl for CallUUID %s" % call_uuid)
else:
if self.get_server().default_hangup_url:
hangup_url = self.get_server().default_hangup_url
self.log.debug("Using HangupUrl from DefaultHangupUrl for CallUUID %s" % call_uuid)
elif event["variable_plivo_answer_url"]:
hangup_url = event["variable_plivo_answer_url"]
self.log.debug("Using HangupUrl from AnswerUrl for CallUUID %s" % call_uuid)
elif self.get_server().default_answer_url:
hangup_url = self.get_server().default_answer_url
self.log.debug("Using HangupUrl from DefaultAnswerUrl for CallUUID %s" % call_uuid)
if not hangup_url:
self.log.debug("No HangupUrl for Incoming CallUUID %s" % call_uuid)
return
called_num = event["variable_plivo_destination_number"]
if not called_num or called_num == "_undef_":
called_num = event["Caller-Destination-Number"] or ""
called_num = called_num.lstrip("+")
caller_num = event["Caller-Caller-ID-Number"]
direction = event["Call-Direction"]
# case outgoing call, add params
else:
self.log.info(
"Hangup for Outgoing CallUUID %s Completed, HangupCause %s, RequestUUID %s"
% (call_uuid, reason, request_uuid)
)
try:
call_req = self.call_requests[request_uuid]
called_num = call_req.to.lstrip("+")
caller_num = call_req._from
if call_req._accountsid:
params["AccountSID"] = call_req._accountsid
direction = "outbound"
self.call_requests[request_uuid] = None
del self.call_requests[request_uuid]
except (KeyError, AttributeError):
called_num = ""
caller_num = ""
direction = "outbound"
self.log.debug("Call Cleaned up for RequestUUID %s" % request_uuid)
if not hangup_url:
self.log.debug("No HangupUrl for Outgoing Call %s, RequestUUID %s" % (call_uuid, request_uuid))
return
forwarded_from = get_substring(":", "@", event["variable_sip_h_Diversion"])
aleg_uuid = event["Caller-Unique-ID"]
aleg_request_uuid = event["variable_plivo_request_uuid"]
sched_hangup_id = event["variable_plivo_sched_hangup_id"]
params["RequestUUID"] = request_uuid
if forwarded_from:
params["ForwardedFrom"] = forwarded_from.lstrip("+")
if aleg_uuid:
params["ALegUUID"] = aleg_uuid
if aleg_request_uuid:
params["ALegRequestUUID"] = aleg_request_uuid
if sched_hangup_id:
params["ScheduledHangupId"] = sched_hangup_id
# if hangup url, handle http request
if hangup_url:
sip_uri = event["variable_plivo_sip_transfer_uri"] or ""
if sip_uri:
params["SIPTransfer"] = "true"
params["SIPTransferURI"] = sip_uri
params["CallUUID"] = call_uuid or ""
params["HangupCause"] = reason
params["To"] = called_num or ""
params["From"] = caller_num or ""
params["Direction"] = direction or ""
params["CallStatus"] = "completed"
spawn_raw(self.send_to_url, hangup_url, params)
