def incoming_twilio_phone_client_loader(request):
from twilio.util import TwilioCapability
account_sid = "AC260e405c96ce1eddffbddeee43a13004"
auth_token = "fd219130e257e25e78613adc6c003d1a"
capability = TwilioCapability(account_sid, auth_token)
capability.allow_client_incoming(str(request.user.username))
return render(request, 'comm/incoming_phone.html', locals())
def token():
account_sid = os.environ.get("ACCOUNT_SID", ACCOUNT_SID)
auth_token = os.environ.get("AUTH_TOKEN", AUTH_TOKEN)
app_sid = os.environ.get("APP_SID", APP_SID)
capability = TwilioCapability(account_sid, auth_token)
# This allows outgoing connections to TwiML application
if request.values.get("allowOutgoing") != "false":
capability.allow_client_outgoing(app_sid)
# This allows incoming connections to client (if specified)
# client = request.values.get('client')
client = "simon" # test client fixe
if client != None:
capability.allow_client_incoming(client)
# This returns a token to use with Twilio based on the account and capabilities defined above
##### GC return TOKEN in JSON
# print 'Content-Type: application/json\n\n'
# twilphonetoken = capability.generate()
# json_data = '{"twilioToken":' + json.dumps(twilphonetoken) + '}'
# callback = request.values.get('callback')
# return '%s(%s)' % (callback, json_data)
#####
# This returns a token to use with Twilio based on the account and capabilities defined above
return capability.generate()
def auth():
capability = TwilioCapability(app.config['TWILIO_ACCOUNT_SID'],
app.config['TWILIO_AUTH_TOKEN'])
capability.allow_client_incoming("swarm_user")
capability.allow_client_outgoing(app.config['TWILIO_APP_SID'])
token = capability.generate()
return str(token)
def get_capability():
user = g.user
capability = TwilioCapability(current_app.config['TWILIO_ACCOUNT_SID'],
current_app.config['TWILIO_AUTH_TOKEN'])
capability.allow_client_incoming(user.username)
capability.allow_client_outgoing(current_app.config['TWILIO_ACCOUNT_SID'])
return capability.generate()
def authorize_user(self, request_data):
facebook_provider = FacebookProvider()
user_info = facebook_provider.get_user_info(request_data["access_token"])
user_info["likes"] = facebook_provider.get_user_likes(request_data["access_token"])
user_info["pictures"] = facebook_provider.get_user_profile_pictures(request_data["access_token"])
user_info["friends"] = facebook_provider.get_user_friends(request_data["access_token"])
db_user_info = db.tow.users.find_one({"facebook_id": user_info["facebook_id"]}, {"_id": 1})
if db_user_info:
user_info["date_modified"] = datetime.utcnow()
db.tow.users.update({"facebook_id": user_info["facebook_id"]}, {"$set": user_info})
user_info["_id"] = db_user_info["_id"]
else:
user_info["date_created"] = datetime.utcnow()
user_info["date_modified"] = datetime.utcnow()
user_info["_id"] = db.tow.users.insert(user_info)
twilio_auth = TwilioCapability("AC28112a0d9703cebb067723c494f7afa1", "8a41f0807e4b022fd4357b2db4560bff")
twilio_auth.allow_client_incoming(str(user_info["_id"]))
twilio_auth.allow_client_outgoing("APc977ec85dc01e1d91c79331e2a22a9c6")
twilio_token = twilio_auth.generate(60 * 60 * 24)
result = \
{
"id": str(user_info["_id"]),
"first_name": user_info["first_name"],
"token": twilio_token,
"is_active": True
}
return result
def start(client_name):
twilio_capability = TwilioCapability(TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN)
twilio_capability.allow_client_incoming(client_name)
capability_token = twilio_capability.generate()
return render_template('client.html', capability_token=capability_token, client_name=client_name)
def index(request):
capability = TwilioCapability(TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN)
application_sid = "APabe7650f654fc34655fc81ae71caa3ff"
capability.allow_client_outgoing(application_sid)
capability.allow_client_incoming("jenny")
token = capability.generate()
print(token)
return TemplateResponse(request, 'index.html', {'token': token})
def test_inbound_permissions(self):
token = TwilioCapability("AC123", "XXXXX")
token.allow_client_incoming("andy")
payload = token.payload()
eurl = "scope:client:incoming?clientName=andy"
assert_equal(len(payload), 1)
assert_equal(payload['scope'], eurl)
def test_inbound_permissions(self):
token = TwilioCapability("AC123", "XXXXX")
token.allow_client_incoming("andy")
payload = token.payload()
eurl = "scope:client:incoming?clientName=andy"
assert_equal(len(payload), 1)
assert_equal(payload['scope'], eurl)
def client():
"""Respond to incoming requests"""
client_name = request.values.get('client', None) or "jenny"
capability = TwilioCapability(account_sid, auth_token)
capability.allow_client_outgoing(application_sid)
capability.allow_client_incoming(client_name)
token = capability.generate()
return render_template('client.html', token=token, client_name=client_name)
def get(self):
capability = TwilioCapability(self.app.config.get('account_sid'), self.app.config.get('auth_token'))
capability.allow_client_outgoing(self.app.config.get('application_sid'))
capability.allow_client_incoming('agent1')
token = capability.generate()
params = {'token': token}
jinja_env = self.app.config.get('template')
template_environment = jinja_env('views').get_template('index.html')
self.response.write(template_environment.render(params))
def send_web_msg():
capability = TwilioCapability(TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN)
capability.allow_client_incoming(default_client)
capability.allow_client_outgoing(TWILIO_APP_SID)
cap_token = capability.generate()
print cap_token
return render_template('send_web_msg.html', cap_token=cap_token, phone_number=default_number)
def client():
"""Respond to incoming requests."""
capability = TwilioCapability(account_sid, auth_token)
capability.allow_client_outgoing(application_sid)
capability.allow_client_incoming("tobias")
token = capability.generate()
return render_template('client.html', token=token)
def test_client(request):
capability = TwilioCapability(settings.TWILIO_ACCOUNT_SID, settings.TWILIO_AUTH_TOKEN)
capability.allow_client_outgoing(settings.TWILIO_APP_SID)
capability.allow_client_incoming('test')
token = capability.generate()
return render(request, 'client.html', {
'token': token
})
def index():
# Create a capability token for this client instance
capability = TwilioCapability(TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN)
# If the client attempts an outgoing call, invoke a TwiML app
capability.allow_client_outgoing("AP17a745dc5cfc00000000000000000000")
# We can make incoming calls to this client with <dial><client>david</client></dial>
capability.allow_client_incoming("david")
token = capability.generate()
return render_template("client_browser.html",
capability_token=token)
def get(self, name):
capability = TwilioCapability(TWILIO_CONFIG.account_sid, TWILIO_CONFIG.auth_token)
number = self.rolodex.get_number(name)
uniq_client_name = number
capability.allow_client_incoming(uniq_client_name)
self.render("phone.html",
device_token=capability.generate(),
pp_phone=util.pp_phone,
name=name,
number=number)
def get_twilio_token(self, user_info):
twilio_auth = TwilioCapability("AC28112a0d9703cebb067723c494f7afa1", "8a41f0807e4b022fd4357b2db4560bff")
twilio_auth.allow_client_incoming(user_info["id"])
twilio_auth.allow_client_outgoing("APc977ec85dc01e1d91c79331e2a22a9c6")
result = \
{
"token": twilio_auth.generate(60 * 60 * 24),
"user_id": user_info["id"]
}
return result
def index(request):
account_sid = settings.TWILIO_ACCOUNT_SID
auth_token = settings.TWILIO_AUTH_TOKEN
application_sid = settings.TWILIO_APPLICATION_SID
capability = TwilioCapability(account_sid, auth_token)
capability.allow_client_outgoing(application_sid)
capability.allow_client_incoming(request.user.username)
twilio_token = capability.generate()
return TemplateResponse(request, 'browser-phone.html', locals())
def index(request):
account_sid = settings.TWILIO_ACCOUNT_SID
auth_token = settings.TWILIO_AUTH_TOKEN
application_sid = settings.TWILIO_APPLICATION_SID
capability = TwilioCapability(account_sid, auth_token)
capability.allow_client_outgoing(application_sid)
capability.allow_client_incoming(request.user.username)
twilio_token = capability.generate()
return TemplateResponse(request, 'browser-phone.html', locals())
def get(self, *a, **kw):
# Find these values at twilio.com/user/account
account_sid = "ACd61a084824884699a1413e71f40a3b5a"
auth_token = TWILIO_AUTH_TOKEN
capability = TwilioCapability(account_sid, auth_token)
capability.allow_client_outgoing('AP1812e773105345a397a849121138359a')
capability.allow_client_incoming('test')
token = capability.generate()
self.render("templates/client.html", token=token)
def client():
"""Respond to incoming requests."""
capability = TwilioCapability(ACCOUNT_SID, AUTH_TOKEN)
application_sid = "APabe7650f654fc34655fc81ae71caa3ff"
application_sid2 = "AP123"
capability.allow_client_outgoing(application_sid2)
capability.allow_client_incoming(default_client)
token = capability.generate()
return render_template('client.html', token=token, client_name=default_client)
def client():
configuration_error = None
for key in ("TWILIO_ACCOUNT_SID", "TWILIO_AUTH_TOKEN", "TWILIO_APP_SID", "TWILIO_CALLER_ID"):
if not app.config[key]:
configuration_error = "Missing from local_settings.py: " "%s" % key
token = None
if not configuration_error:
capability = TwilioCapability(app.config["TWILIO_ACCOUNT_SID"], app.config["TWILIO_AUTH_TOKEN"])
capability.allow_client_incoming("joey_ramone")
capability.allow_client_outgoing(app.config["TWILIO_APP_SID"])
token = capability.generate()
return render_template("client.html", token=token, configuration_error=configuration_error)
def build_twilio_token(client_name):
account_sid = 'AC9dbcad82b20275e6e1854351444f13c3'
auth_token = 'd5eb94487e911314e5620b4ea18e6d74'
capability = TwilioCapability(account_sid, auth_token)
app_sid = 'AP4679912e15024febe5d6d1fc814e7c7d'
capability.allow_client_outgoing(app_sid)
capability.allow_client_incoming(client_name)
return capability.generate()
def get_capability_token():
"""Respond to incoming requests."""
# Find these values at twilio.com/console
account_sid = 'ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
auth_token = 'your_auth_token'
capability = TwilioCapability(account_sid, auth_token)
capability.allow_client_incoming("jenny")
token = capability.generate()
return Response(token, mimetype='application/jwt')
def create_token(client_name): # get credentials for environment variables account_sid = 'ACf49e7e3210b0d62e18d0896c43faec2d' auth_token = 'cda8d559b05c77535967c816ce076b2c' capability = TwilioCapability(account_sid, auth_token) # app sid for TwiML app application_sid = app.config['TWILIO_APPLICATION_SID'] capability.allow_client_outgoing(application_sid) capability.allow_client_incoming(client_name) return capability.generate()
def build_twilio_token(client_name):
# Find these values at twilio.com/user/account
account_sid = "TWILIO_ACCOUNT_SID"
auth_token = "TWILIO_AUTH_TOKEN"
cap = TwilioCapability(account_sid, auth_token)
app_sid = ''
cap.allow_client_outgoing(app_sid)
cap.allow_client_incoming(client_name)
return cap.generate()
def build_twilio_token(client_name):
# Find these values at twilio.com/user/account
account_sid = "TWILIO_ACCOUNT_SID"
auth_token = "TWILIO_AUTH_TOKEN"
cap = TwilioCapability(account_sid, auth_token)
app_sid = ''
cap.allow_client_outgoing(app_sid)
cap.allow_client_incoming(client_name)
return cap.generate()
def token():
# get credentials for environment variables
# Generate a random user name
identity = alphanumeric_only.sub('', fake.user_name())
# Create a Capability Token
capability = TwilioCapability(account_sid, auth_token)
capability.allow_client_outgoing(application_sid)
capability.allow_client_incoming(identity)
token = capability.generate()
# Return token info as JSON
return jsonify(identity=identity, token=token)
def client():
"""Respond to incoming requests."""
# Find these values at twilio.com/user/account
account_sid = "AC3d6188091a9109165c89ae83c5d94d1b"
auth_token = "7a0007278ebe72b311ca4d476c7a6abc"
capability = TwilioCapability(account_sid, auth_token)
application_sid = "APcdc54402e77bd0aa98ab42bd5d045f89" # Twilio Application Sid
capability.allow_client_incoming("ram")
token = capability.generate()
return render_template('client.html', token=token)
def generate_token(self):
sid_account = request.env.user.company_id.twilio_account_sid
token_account = request.env.user.company_id.twilio_auth_token
sid_twiml = request.env.user.company_id.twiml_application
capability = TwilioCapability(sid_account, token_account)
# Allow our users to make outgoing calls with Twilio Client
capability.allow_client_outgoing(sid_twiml)
capability.allow_client_incoming('support_agent')
# Generate the capability token
token = capability.generate()
return token
def client():
"""Respond to incoming requests."""
# Find these values at twilio.com/user/account
account_sid = "AC3d6188091a9109165c89ae83c5d94d1b"
auth_token = "7a0007278ebe72b311ca4d476c7a6abc"
capability = TwilioCapability(account_sid, auth_token)
application_sid = "APcdc54402e77bd0aa98ab42bd5d045f89" # Twilio Application Sid
capability.allow_client_incoming("ram")
token = capability.generate()
return render_template("client.html", token=token)
def client():
"""Respond to incoming requests."""
# Find these values at twilio.com/user/account
account_sid = "AC9c5adc79b9cf3d79fc46f47fa6165c1e"
auth_token = "6c79f8833d77a2a0433db0418d33d0c7"
capability = TwilioCapability(account_sid, auth_token)
application_sid = "APaa7ff4fb5efb45971236e6762e90b1ba" # Twilio Application Sid
capability.allow_client_outgoing(application_sid)
capability.allow_client_incoming("jenny")
token = capability.generate()
return render_template('client.html', token=token)
def client():
"""Respond to incoming requests."""
# Find these values at twilio.com/user/account
account_sid = "AC9c5adc79b9cf3d79fc46f47fa6165c1e"
auth_token = "6c79f8833d77a2a0433db0418d33d0c7"
capability = TwilioCapability(account_sid, auth_token)
application_sid = "APaa7ff4fb5efb45971236e6762e90b1ba" # Twilio Application Sid
capability.allow_client_outgoing(application_sid)
capability.allow_client_incoming("jenny")
token = capability.generate()
return render_template('client.html', token=token)
def client():
"""Respond to incoming requests."""
# Find these values at twilio.com/user/account
account_sid = data["account_sid"]
auth_token = data["auth_token"]
capability = TwilioCapability(account_sid, auth_token)
application_sid = data["application_sid"] # Twilio Application Sid
capability.allow_client_outgoing(application_sid)
capability.allow_client_incoming("jenny")
token = capability.generate()
return render_template('client.html', token=token)
def get_token(request):
"""Returns a Twilio Client token.
Create a TwilioCapability object with our Twilio API credentials."""
capability = TwilioCapability(
settings.TWILIO_ACCOUNT_SID,
settings.TWILIO_AUTH_TOKEN)
"""Allow our users to make outgoing calls with Twilio Client"""
capability.allow_client_outgoing(settings.TWIML_APPLICATION_SID)
"""Allow our users to accept incoming calls from pyphon"""
capability.allow_client_incoming('caller')
"""Generate the capability token"""
token = capability.generate()
return JsonResponse({'token': token})
def test_decode(self):
token = TwilioCapability("AC123", "XXXXX")
token.allow_client_outgoing("AP123", foobar=3)
token.allow_client_incoming("andy")
token.allow_event_stream()
outgoing_uri = "scope:client:outgoing?appParams=foobar%3D3&appSid=AP123&clientName=andy"
incoming_uri = "scope:client:incoming?clientName=andy"
event_uri = "scope:stream:subscribe?path=%2F2010-04-01%2FEvents"
result = jwt.decode(token.generate(), "XXXXX")
scope = result["scope"].split(" ")
self.assertIn(outgoing_uri, scope)
self.assertIn(incoming_uri, scope)
self.assertIn(event_uri, scope)
def test_decode(self):
token = TwilioCapability("AC123", "XXXXX")
token.allow_client_outgoing("AP123", foobar=3)
token.allow_client_incoming("andy")
token.allow_event_stream()
outgoing_uri = "scope:client:outgoing?appParams=foobar%3D3&appSid=AP123&clientName=andy"
incoming_uri = "scope:client:incoming?clientName=andy"
event_uri = "scope:stream:subscribe?path=%2F2010-04-01%2FEvents"
result = jwt.decode(token.generate(), "XXXXX")
scope = result["scope"].split(" ")
self.assertIn(outgoing_uri, scope)
self.assertIn(incoming_uri, scope)
self.assertIn(event_uri, scope)
def client():
configuration_error = None
for key in ('TWILIO_ACCOUNT_SID', 'TWILIO_AUTH_TOKEN', 'TWILIO_APP_SID',
'TWILIO_CALLER_ID'):
if not app.config[key]:
configuration_error = "Missing from local_settings.py: %s" % key
token = None
if not configuration_error:
capability = TwilioCapability(app.config['TWILIO_ACCOUNT_SID'],
app.config['TWILIO_AUTH_TOKEN'])
capability.allow_client_incoming("joey_ramone")
capability.allow_client_outgoing(app.config['TWILIO_APP_SID'])
token = capability.generate()
params = {'token': token}
return render_template('client.html', params=params,
configuration_error=configuration_error)
def get_capability_token():
"""Respond to incoming requests."""
# Find these values at twilio.com/console
account_sid = 'ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
auth_token = 'your_auth_token'
capability = TwilioCapability(account_sid, auth_token)
# Twilio Application Sid
application_sid = 'APXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
capability.allow_client_outgoing(application_sid)
capability.allow_client_incoming(request.form["ClientName"])
token = capability.generate()
return Response(token, mimetype='application/jwt')
def client():
"""Respond to incoming requests."""
account_sid = "AC566da319c49345fe4fbbbea81ada1de0"
auth_token = "741080b04bcb6c2471cf9439d939abce"
capability = TwilioCapability(account_sid, auth_token)
# This is a special Quickstart application sid - or configure your own
# at twilio.com/user/account/apps
application_sid = "APabe7650f654fc34655fc81ae71caa3ff"
capability.allow_client_outgoing(application_sid)
capability.allow_client_incoming("JohnCorndog")
token = capability.generate()
return render_template('client.html', token=token)
def incomingWidget(request):
callsid = request.GET['callsid']
group_id = request.GET['group_id']
number = request.GET['number']
account_sid = TWILIO_ACCOUNT_SID
auth_token = TWILIO_AUTH_TOKEN
capability = TwilioCapability(account_sid, auth_token)
application_sid = APPLICATION_SID
capability.allow_client_incoming(callsid)
token = capability.generate()
context_dict = {}
context_dict['token'] = token
context_dict['number'] = number
context_dict['group_id'] = "g:" + group_id
# TODO
# change this to incoming call
return render(request, 'incoming.html', context_dict)
def token():
account_sid = os.environ.get("ACCOUNT_SID", ACCOUNT_SID)
auth_token = os.environ.get("AUTH_TOKEN", AUTH_TOKEN)
app_sid = os.environ.get("APP_SID", APP_SID)
capability = TwilioCapability(account_sid, auth_token)
# This allows outgoing connections to TwiML application
if request.values.get('allowOutgoing') != 'false':
capability.allow_client_outgoing(app_sid)
# This allows incoming connections to client (if specified)
client = request.values.get('client')
if client != None:
capability.allow_client_incoming(client)
# This returns a token to use with Twilio based on the account and capabilities defined above
return capability.generate()
def client():
global pending_call_token
token = request.args.get("token")
print "/"
print "pending_call_token: {}".format(pending_call_token)
print "token: {}".format(token)
if pending_call_token and (token == pending_call_token):
capability = TwilioCapability(twilio_account_sid, twilio_auth_token)
capability.allow_client_outgoing(twilio_application_sid)
capability.allow_client_incoming(twilio_client_name)
twilio_token = capability.generate()
return render_template('client.html',
twilio_token=twilio_token,
call_token=pending_call_token,
door_unlock_digits=door_unlock_digits)
else:
return render_template("answered.html")
def reqclient():
"""Respond to incoming requests."""
client_name = request.values.get('client', None) or "jenny"
# Find these values at twilio.com/user/account
account_sid = __ACCOUNT_SID
auth_token = __AUTH_TOKEN
capability = TwilioCapability(account_sid, auth_token)
application_sid = "APabe7650f654fc34655fc81ae71caa3ff" # Twilio Application Sid
capability.allow_client_outgoing(application_sid)
capability.allow_client_incoming(client_name)
token = capability.generate()
return render_template('client.html',
token=token,
appID=__APP_ID,
appSecret=__APP_SECRET,
client_name=client_name)
def get_token(request):
"""Returns a Twilio Client token"""
# Create a TwilioCapability object with our Twilio API credentials
capability = TwilioCapability(settings.TWILIO_ACCOUNT_SID,
settings.TWILIO_AUTH_TOKEN)
# Allow our users to make outgoing calls with Twilio Client
capability.allow_client_outgoing(settings.TWIML_APPLICATION_SID)
# If the user is on the support dashboard page, we allow them to accept
# incoming calls to "support_agent"
# (in a real app we would also require the user to be authenticated)
if request.GET['forPage'] == reverse('dashboard'):
capability.allow_client_incoming('support_agent')
else:
# Otherwise we give them a name of "customer"
capability.allow_client_incoming('customer')
# Generate the capability token
token = capability.generate()
return JsonResponse({'token': token})
def generate(agent_id):
account_sid = ENV['TWILIO_ACCOUNT_SID']
auth_token = ENV['TWILIO_AUTH_TOKEN']
capability = TwilioCapability(account_sid, auth_token)
capability.allow_client_incoming(agent_id)
return capability.generate()
def get(self):
# force the user to login and get their user model
user = self.current_user
if user:
login = ('%s (<a href="%s">sign out</a>)' % (user.nickname, users.create_logout_url("/")))
else:
self.response.out.write(self.user_login_page)
return
# check the site to determine if the site has been authorized.
# if so, look at the user model to see if they are the owner
# if not, offer the user the ability to authorize the site (this should only happen once)
capability = TwilioCapability(configuration.TWILIO_ACCOUNT_SID,configuration.TWILIO_AUTH_TOKEN)
voicemail = []
if user.activated is False:
owner = db.GqlQuery("select * from User where activated = True").get()
if owner is None:
# start the owner verification sequence.
logging.debug('site verification started for %s' % user.nickname)
code = randint(10000,99999)
user.verification_code = str(code)
user.put()
sendSMS(configuration.SMS_VERIFICATION_PHONE,
'Enter this five digit code in the browser to validate your account %s' % str(code))
template_file = 'templates/owner_verification.html'
else:
# this isn't the owner so they only get the one big button to
# call the owner of the phone
template_file = 'templates/friend.html'
else:
# the owner of the site is both logged in and verified.
# create a dialing interface for them to make outbound calls and
# provide the capability to accept incoming calls.
capability.allow_client_incoming("owner")
logging.debug('the owner is logged in! now granted them incoming capabilities...')
template_file = 'templates/owner.html'
# find all of the user's voicemail
vmail = db.GqlQuery("select * from Voicemail").fetch(10)
for v in vmail:
logging.debug('found voicemail %s' % v.create_date)
message = {'date' : v.create_date,
'from' : v.from_number,
'duration' : v.voicemail_duration,
'url' : v.voicemail_url,
}
voicemail.append(message)
# now make sure the twilio configuration is correct
if validateTwilio() is False:
self.redirect('/error.html')
return
# generate the token based on the configured capabilities.
# everyone can call out, but only the owner can accept incoming calls.
capability.allow_client_outgoing(configuration.TWILIO_APP_SID)
token = capability.generate()
template_values = {'token':token,
'client':'owner',
'login':login,
'voicemail':voicemail,
'current_user':user.nickname,
'google_analytics':configuration.GOOGLE_ANALYTICS_CODE,
'name':configuration.MY_NAME,
'title':configuration.APP_TITLE,
}
# generate the html
path = os.path.join(os.path.dirname(__file__), template_file)
self.response.out.write(template.render(path, template_values))
