def test_outbound_permissions(self): token = TwilioCapability("AC123", "XXXXX") token.allow_client_outgoing("AP123") payload = token.payload() eurl = "scope:client:outgoing?appSid=AP123" self.assertEquals(len(payload), 1) self.assertIn(eurl, payload['scope'])
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 task_profile(request, task_id): task = get_object_or_404(Task, id=task_id) #It wasn't bad enough that the actual create form was wet and silly. Now this too. TODO: FIX THIS F****R. user_can_make_new_prototypes = True #TODO: Turn this into an actual privilege assessment task_prototype_name_form = TaskPrototypeNameForm() task_prototype_name_form.fields['name'].widget.attrs[ 'class'] = "topLevel" #So that we can recognize it later via autocomplete. rest_of_the_task_prototype_form = RestOfTheTaskPrototypeForm() user_privileges = get_privileges_for_user(request.user) #Wet and silly. TODO: Fix class SimpleChildForm(forms.Form): child = AutoCompleteField(models=(TaskPrototype, ), name_visible_field=True) class SimpleParentForm(forms.Form): parent = AutoCompleteField(models=(TaskPrototype, ), name_visible_field=True) task_prototype_form = TaskPrototypeForm() task_prototype_parent_form = SimpleParentForm() task_prototype_child_form = SimpleChildForm() draw_attention_ajax_form = DrawAttentionAjaxForm() if task.prototype.id == 251 or task.prototype.id == 7: has_outgoing_call = True disable_incoming_calls = True account_sid = "AC260e405c96ce1eddffbddeee43a13004" auth_token = "fd219130e257e25e78613adc6c003d1a" capability = TwilioCapability(account_sid, auth_token) capability.allow_client_outgoing("APd13a42e60c91095f3b8683a77ee2dd05") #The text of the call recipient will be the name of the person in the case of a tech job. It will be the output of the unicode method of the PhoneNumber in the case of a PhoneCall resolution. if task.prototype.id == 251: call_to_name = task.related_objects.all()[0].object.get_full_name() related_user = task.related_objects.all()[0].object phone_numbers = task.related_objects.all( )[0].object.userprofile.contact_info.phone_numbers.all() if task.prototype.id == 7: phone_numbers = [task.related_objects.all()[0].object.from_number] if task.related_objects.all()[0].object.from_number.owner: call_to_name = task.related_objects.all( )[0].object.from_number.owner else: call_to_name = "Phone Number #%s" % (str( task.related_objects.all()[0].object.id)) return render(request, 'do/task_profile.html', locals())
def get_context_data(self, **kwargs): context = super(TwillioView, self).get_context_data(**kwargs) context['account_sid'] = settings.TWILLIO_ACCOUNT_SID context['auth_token'] = settings.TWILLIO_AUTH_TOKEN context['auth_token'] = settings.TWILLIO_APP_SID capability = TwilioCapability(settings.TWILLIO_ACCOUNT_SID, settings.TWILLIO_AUTH_TOKEN) capability.allow_client_outgoing(settings.TWILLIO_APP_SID) context['token'] = capability.generate() return context
def index(): reason, source = reasonSonyaIsAwesome().split('::') capability = TwilioCapability(app.config['ACCOUNT_SID'], app.config['AUTH_TOKEN']) capability.allow_client_outgoing(app.config['SONYA_APP_SID']) token = capability.generate() return render_template('index.html', token=token, reason=reason, source=source)
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 client(request): account_sid = TWILIO_ACCOUNT_SID auth_token = TWILIO_AUTH_TOKEN capability = TwilioCapability(account_sid, auth_token) application_sid = APPLICATION_SID capability.allow_client_outgoing(application_sid) token = capability.generate() context_dict = {} context_dict['token'] = token return render(request, 'client.html', context_dict)
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_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 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 test(self, var=None, **params): room = str(urllib.unquote(cherrypy.request.params['room'])) user = str(urllib.unquote(cherrypy.request.params['user'])) capability = TwilioCapability(account, token) capability.allow_client_outgoing(application_sid) template_values = { "token": capability.generate(), "room": room, "user": user } t = loader.get_template('test.html') c = Context(template_values) return t.render(c)
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 main_page(): """Respond to incoming requests.""" account_sid = "" auth_token = "" 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 = "APaf6c7ab08a32e7fb541a78d97d592100" capability.allow_client_outgoing(application_sid) token = capability.generate() return render_template('index.html', token=token)
def main(self, var=None, **params): clientid = urllib.unquote(cherrypy.request.params['id']) room = clientid.split(".")[0] user = clientid.split(".")[1] capability = TwilioCapability(account, token) capability.allow_client_outgoing(application_sid) template_values = { "token": capability.generate(), "room": room, "user": user } t = loader.get_template('mainclient.html') c = Context(template_values) return t.render(c)
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 dispatch(self, request, *args, **kwargs): account_sid = settings.TWILIO_ACCOUNT_SID auth_token = settings.TWILIO_AUTH_TOKEN application_sid = settings.TWILIO_CALLBACK_APP_SID capability = TwilioCapability(account_sid, auth_token) capability.allow_client_outgoing(application_sid) token = capability.generate() manager = request.user.callbackmanager return JsonResponse({ 'token': token, 'manager': Signer().sign(manager.pk) })
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.""" account_sid = "ACdfd86ae9d14d1932491fb8d18c1bc983" auth_token = "31999b4fabf7b98ba4491738c9b4c493" # This is a special Quickstart application sid - or configure your own # at twilio.com/user/account/apps application_sid = "APabe7650f654fc34655fc81ae71caa3ff" capability = TwilioCapability(account_sid, auth_token) capability.allow_client_outgoing(application_sid) token = capability.generate() return render_template('client.html', token=token)
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 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 capability_token(request): mhluser_id = request.user.id capability = TwilioCapability(settings.TWILIO_ACCOUNT_SID, settings.TWILIO_ACCOUNT_TOKEN) capability.allow_client_outgoing(settings.TWILIO_APP_SID) capabilityToken = capability.generate() response = { 'data': { 'capabilityToken': capabilityToken, 'mhluser_id': mhluser_id }, 'warnings': {}, } print json.dumps(response) return HttpResponse(content=json.dumps(response), mimetype='application/json')
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 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 index(): # Make sure we have this host configured properly. config_errors = [] for option in ['TWILIO_ACCOUNT_SID', 'TWILIO_AUTH_TOKEN']: if not app.config[option]: config_errors.append("%s is not configured for this host." % option) # Define important links params = { 'sms_request_url': url_for('.sms', _external=True), 'config_errors': config_errors } # Generate capability token capability = TwilioCapability(app.config['TWILIO_ACCOUNT_SID'], app.config['TWILIO_AUTH_TOKEN']) capability.allow_client_outgoing(app.config['TWILIO_APP_SID']) token = capability.generate() # If not a submission, render form. return render_template('index.html', params=params, token=token)