def token(request): identity = request.GET.get('identity', fake.user_name()) device_id = request.GET.get('device', 'default') # unique device ID account_sid = settings.TWILIO_ACCOUNT_SID api_key = settings.TWILIO_API_KEY api_secret = settings.TWILIO_API_SECRET chat_service_sid = settings.TWILIO_CHAT_SERVICE_SID token = AccessToken(account_sid, api_key, api_secret, identity=identity) # Create a unique endpoint ID for the device endpoint = "MyDjangoChatRoom:{0}:{1}".format(identity, device_id) if chat_service_sid: chat_grant = ChatGrant(endpoint_id=endpoint, service_sid=chat_service_sid) token.add_grant(chat_grant) response = { 'identity': identity, 'token': token.to_jwt().decode('utf-8') } return JsonResponse(response)
def generate_token(username, roomname): token = AccessToken(twilio_account_sid, twilio_api_key_sid, twilio_api_key_secret, identity=username) token.add_grant(VideoGrant(room=roomname)) return token.to_jwt().decode()
def get_chat_token(username): logger.info(f'Generating Chat token for {username}') # This call is simply to ensure the service exists service = get_service() token = AccessToken(settings.TWILIO_ACCOUNT_SID, settings.TWILIO_API_KEY, settings.TWILIO_API_SECRET, identity=username) sync_grant = SyncGrant(service_sid='default') token.add_grant(sync_grant) chat_grant = ChatGrant(service_sid=service.sid) token.add_grant(chat_grant) # Expire token in three minutes expiration = 180 jwt_token = token.to_jwt(ttl=expiration).decode("utf-8") # Cache the token, set to expire after the token expires cache.set(f'tokens:chat:{username}', jwt_token, expiration) return jwt_token
def on_room_entry_request(data): user_id = (models.DB.session.query( models.CurrentConnections.user).filter_by( sid=flask.request.sid).first()) models.DB.session.add(models.EnteredRooms(user_id, data["roomId"])) models.DB.session.commit() socketio.emit("room entry accepted", room=flask.request.sid) flask_socketio.join_room(str(data["roomId"])) print("room entry accepted") emit_room_history(flask.request.sid) username = models.DB.session.query( models.AuthUser.username).filter_by(id=user_id).first()[0] if data['roomId'] not in roomTokens.keys(): token = AccessToken(twilio_account_sid, twilio_api_key_sid, twilio_api_key_secret, identity=username) roomTokens[data['roomId']] = token token.add_grant(VideoGrant(room=data['roomId'])) socketio.emit( "token", { 'tokens': token.to_jwt().decode(), 'room': str(data['roomId']), 'username': username }) else: token = roomTokens[data['roomId']] token.identity = username socketio.emit( "token", { 'tokens': token.to_jwt().decode(), 'room': str(data['roomId']), 'username': username })
def twilio_api_chat(): from twilio.jwt.access_token import AccessToken from twilio.jwt.access_token.grants import ChatGrant from twilio.rest import Client service_sid = 'IScb01dd8aeded43f1961957e46cfcf717' identity = request.args.get('identity') # required for all twilio access tokens account_sid = 'AC1ab30057b0be6eaaa144ff94b773c882' auth_token = '6ec8894a7733967f155c26d39feadf3a' client = Client(account_sid, auth_token) ACCOUNT_SID = account_sid API_KEY_SID = 'SK08e688a95ac12a599a36deb2aec64a68' API_KEY_SECRET = 'akrwxUmAompQjVNnpExLgOkMAf2m45iC' token = AccessToken(ACCOUNT_SID, API_KEY_SID, API_KEY_SECRET, identity=identity) # Create an Chat grant and add to token chat_grant = ChatGrant(service_sid=service_sid) token.add_grant(chat_grant) print(token.to_jwt().decode('utf-8')) return ujson.dumps({ 'token': token.to_jwt(), 'identity': identity })
def twilio_api_video(): from twilio.jwt.access_token import AccessToken from twilio.jwt.access_token.grants import VideoGrant from twilio.rest import Client name = request.args.get('name') room = request.args.get('room') ACCOUNT_SID = 'AC0899dfbac4d4374a162ad3f494a29cb9' API_KEY_SID = 'SK0d73ceea012fd7a740cfea97b091b11f' API_KEY_SECRET = '9c2gxH04Fd2RNV9EePMYW1XmeNP1ehOm' # Create an Access Token token = AccessToken(ACCOUNT_SID, API_KEY_SID, API_KEY_SECRET, identity=name) # Grant access to Video grant = VideoGrant(room=room) token.add_grant(grant) print(token.to_jwt()) return ujson.dumps({ 'token': token.to_jwt(), 'name': name, 'room': room })
def generate_voice_access_token(self, from_number: str, identity_postfix=None, ttl=60 * 60): """Generates a token required to make voice calls from the browser. """ # identity is used by twilio to identify the user uniqueness at browser(or any endpoints). identity = from_number if identity_postfix: identity = '_'.join( [identity, self.safe_identity(identity_postfix)]) # Create access token with credentials token = AccessToken(self.account_sid, self.api_key, self.api_secret, identity=identity, ttl=ttl) # Create a Voice grant and add to token voice_grant = VoiceGrant( outgoing_application_sid=self.application_sid, incoming_allow=True, # Allow incoming calls ) token.add_grant(voice_grant) return token.to_jwt()
def token(): client_name = request.values.get('client') platform = request.values.get('platform') account_sid = os.environ.get("ACCOUNT_SID", ACCOUNT_SID) api_key = os.environ.get("API_KEY", API_KEY) api_key_secret = os.environ.get("API_KEY_SECRET", API_KEY_SECRET) app_sid = os.environ.get("APP_SID", APP_SID) if platform == 'iosdev': push_credential_sid = os.environ.get("PUSH_CREDENTIAL_SID_IOS", PUSH_CREDENTIAL_SID_IOS_DEV) elif platform == 'iosprod': push_credential_sid = os.environ.get("PUSH_CREDENTIAL_SID_IOS", PUSH_CREDENTIAL_SID_IOS_PROD) else: push_credential_sid = os.environ.get("PUSH_CREDENTIAL_SID_ANDROID", PUSH_CREDENTIAL_SID_ANDROID) if client_name: IDENTITY =client_name grant = VoiceGrant( push_credential_sid=push_credential_sid, outgoing_application_sid=app_sid ) token = AccessToken(account_sid, api_key, api_key_secret, IDENTITY) token.add_grant(grant) k = {'accessToken': str(token)} return json.dumps(k)
def token(): user_id = request.args.get('user') if not user_id: return "Invalid user" platform = request.args.get('platform') if not platform: return "Invalid platform" account_sid = os.environ.get("ACCOUNT_SID", ACCOUNT_SID) api_key = os.environ.get("API_KEY", API_KEY) api_key_secret = os.environ.get("API_KEY_SECRET", API_KEY_SECRET) user_identity = 'agent_' + user_id if platform == 'android': push_credential = os.environ.get("ANDROID_PUSH_CREDENTIAL_SID", ANDROID_PUSH_CREDENTIAL_SID) else: push_credential = os.environ.get("IOS_PUSH_CREDENTIAL_SID", IOS_PUSH_CREDENTIAL_SID) grant = VoiceGrant( push_credential_sid=push_credential ) token = AccessToken(account_sid, api_key, api_key_secret, user_identity) token.add_grant(grant) return str(token)
def token(): client_name = request.values.get('client') platform = request.values.get('platform') account_sid = os.environ.get('ACCOUNT_SID', ACCOUNT_SID) api_key = os.environ.get('API_KEY', API_KEY) api_key_secret = os.environ.get('API_KEY_SECRET', API_KEY_SECRET) app_sid = os.environ.get('APP_SID', APP_SID) if platform == 'ios': push_credential_sid = os.environ.get('PUSH_CREDENTIAL_SID_IOS', PUSH_CREDENTIAL_SID_IOS) else: push_credential_sid = \ os.environ.get('PUSH_CREDENTIAL_SID_ANDROID', PUSH_CREDENTIAL_SID_ANDROID) if client_name: IDENTITY = client_name grant = VoiceGrant(push_credential_sid=push_credential_sid, outgoing_application_sid=app_sid) token = AccessToken(account_sid, api_key, api_key_secret, IDENTITY) token.add_grant(grant) return str(token)
def generateToken(identity): # Get credentials from environment variables account_sid = settings.TWILIO_ACCT_SID chat_service_sid = settings.TWILIO_CHAT_SID sync_service_sid = settings.TWILIO_SYNC_SID api_sid = settings.TWILIO_API_SID api_secret = settings.TWILIO_API_SECRET # Create access token with credentials token = AccessToken(account_sid, api_sid, api_secret, identity=identity) # Create a Sync grant and add to token if sync_service_sid: sync_grant = SyncGrant(service_sid=sync_service_sid) token.add_grant(sync_grant) # Create a Chat grant and add to token if chat_service_sid: chat_grant = ChatGrant(service_sid=chat_service_sid) token.add_grant(chat_grant) # Return token info as JSON return JsonResponse({ 'identity': identity, 'token': token.to_jwt().decode('utf-8') })
def createToken(request): content = request.GET # get the identity from the request, or make one up identity = request.user.username # get credentials for environment variables account_sid = os.environ['TWILIO_ACCOUNT_SID'] api_key = os.environ['TWILIO_API_KEY'] api_secret = os.environ['TWILIO_API_SECRET'] chat_service_sid = os.environ.get('TWILIO_CHAT_SERVICE_SID', None) # Create access token with credentials token = AccessToken(account_sid, api_key, api_secret, identity=identity) # Create an Chat grant and add to token if chat_service_sid: chat_grant = ChatGrant(service_sid=chat_service_sid) token.add_grant(chat_grant) # Return token info as JSON return JsonResponse(data={ "identity": identity, "token": token.to_jwt().decode('utf-8') }, safe=False)
def get_twilio_jwt(identity, room): token = AccessToken(settings.TWILIO_ACCOUNT_SID, settings.TWILIO_API_KEY, settings.TWILIO_API_SECRET, identity=identity) token.add_grant(VideoGrant(room=room)) return token.to_jwt().decode('utf-8')
def create_access_token(): id_user_hash = get_jwt_identity() id_user = db.session.query(Users.id_user).filter( Users.id_user_hash == id_user_hash ).first() if id_user: account_sid = current_app.config["TWILIO_ACCOUNT_SID"] api_sid = current_app.config["TWILIO_API_SID"] api_secret = current_app.config["TWILIO_API_SECRET"] chat_sid = current_app.config["TWILIO_CHAT_SID"] token = AccessToken( account_sid, api_sid, api_secret, identity=id_user_hash, ttl=7200) chat_grant = ChatGrant(service_sid=chat_sid) token.add_grant(chat_grant) return jsonify({ "token": token.to_jwt().decode("utf-8") }), 200 else: return jsonify({ "message": "Invalid credential" }), 401
def login(): username = request.get_json(force=True).get('username') if not username: abort(401) conversation = get_chatroom(os.environ.get('CHATROOM', 'My Room')) conversation_sid = '' if conversation: try: conversation.participants.create(identity=username) except TwilioRestException as ex: # do not error if the user is already in the conversation if ex.status != 409: raise conversation_sid = conversation.sid token = AccessToken(twilio_account_sid, twilio_api_key_sid, twilio_api_key_secret, identity=username) token.add_grant(VideoGrant(room='My Room')) if conversation: token.add_grant( IpMessagingGrant(service_sid=conversation.chat_service_sid)) return { 'token': token.to_jwt().decode(), 'conversation_sid': conversation_sid }
def get_user_twilio_token(self, user_id, context): try: user_id = user_id.value # print("get_user_twilio_token", user_id) TWILIO_ACCOUNT_SID = 'AC0cb509ad66d21f69f2fd6e4b566e2449' TWILIO_API_KEY_SID = 'SK6ea1006b0adabde2957b9077e0a25679' TWILIO_API_KEY_SECRET = 'AP6uPE2wJoVACZlWG2CSnDBI40MRaYfM' # Create an Access Token token = AccessToken(TWILIO_ACCOUNT_SID, TWILIO_API_KEY_SID, TWILIO_API_KEY_SECRET) # Set the Identity of this token token.identity = user_id # Grant access to Video grant = VideoGrant(room='AwesomeRoom') token.add_grant(grant) # Serialize the token as a JWT jwt = token.to_jwt().decode('utf-8') print(jwt) print(user_id) print(token.payload["exp"]) return main_pb2.JWTToken(id=main_pb2.UUID(value=str(user_id)), expiry_time=token.payload["exp"], jwt=jwt) except Exception as e: print("Error in get_user", e) traceback.print_exc(file=sys.stdout)
def video(): identity = random_user() scat = AccessToken(app.config['TWILIO_ACCOUNT_SID'], \ app.config['TWILIO_API_KEY'], app.config['TWILIO_API_SECRET'], identity=identity) scat.add_grant(VideoGrant(room="Room1")) token = scat.to_jwt() value = str(token) value2 = value[2:-1] return jsonify(dict(identity=identity, token=value2))
def create_token(identity): token = AccessToken(account_sid, api_key, api_secret) token.identity = identity # Create a Video grant and add to token video_grant = VideoGrant(room='441') token.add_grant(video_grant) # Return token info as JSON # return {"identity":identity, "token":token.to_jwt()} return token.to_jwt()
def video_access_token(roomId: str, username: str) -> str: token = AccessToken(twilio_account_sid, twilio_api_key_sid, twilio_api_key_secret, identity=username, ttl=3600) token.add_grant(VideoGrant(room=roomId)) return token.to_jwt( ) # This str() is done to work with (slightly) older flask/python version.
def amazon_token(country_code, worker_id): _, identity = get_caller_identity(country_code, worker_id) token = AccessToken(TWILIO_ACCOUNT_SID, TWILIO_API_KEY, TWILIO_API_SECRET, identity=identity) grant = VoiceGrant(outgoing_application_sid=AMAZON_TWIML_APP_SID) token.add_grant(grant) return jsonify({"token": token.to_jwt()})
def generateToken(identity): # Create access token with credentials token = AccessToken(account_sid, api_key, api_secret, identity=identity) if chat_service: chat_grant = ChatGrant(service_sid=chat_service) token.add_grant(chat_grant) # Return token info as JSON return jsonify(identity=identity, token=token.to_jwt().decode('utf-8'))
def get_twilio_token(username, classroom_name): token = AccessToken( settings.TWILIO_ACCOUNT_SID, settings.TWILIO_API_KEY_SID, settings.TWILIO_API_KEY_SECRET, identity=username, ) token.add_grant(VideoGrant(room=classroom_name)) return token.to_jwt().decode()
def login(): username = request.get_json(force=True).get('username') if not username: abort(401) token = AccessToken(twilio_account_sid, twilio_api_key_sid, twilio_api_key_secret, identity=username) token.add_grant(VideoGrant(room='My Room')) return {'token': token.to_jwt().decode(), 'name': username}
def login(): username = request.get_json(force=True).get('username') if not username: abort(401) token = AccessToken(app.config["TWILIO_ACCOUNT_SID"], app.config["TWILIO_API_KEY_SID"], app.config["TWILIO_API_KEY_SECRET"], identity=username) token.add_grant(VideoGrant(room='My Room')) return {'token': token.to_jwt().decode()}
def token(): # get the userid from the incoming request identity = request.values.get('identity', None) # Create access token with credentials token = AccessToken(twilio_account_sid, twilio_api_key, twilio_api_secret, identity=identity) # Create a Sync grant and add to token sync_grant = SyncGrant(service_sid=twilio_sync_service_id) token.add_grant(sync_grant) # Return token info as JSON return jsonify(identity=identity, token=token.to_jwt().decode('utf-8'))
def test_video_grant(self): scat = AccessToken(ACCOUNT_SID, SIGNING_KEY_SID, 'secret') scat.add_grant(VideoGrant(room='CP123')) token = scat.to_jwt() assert_is_not_none(token) decoded_token = AccessToken.from_jwt(token, 'secret') self._validate_claims(decoded_token.payload) assert_equal(1, len(decoded_token.payload['grants'])) assert_equal({'room': 'CP123'}, decoded_token.payload['grants']['video'])
def videologin(request, room_name): identity = request.GET.get('identity', fake.user_name()) token = AccessToken(twilio_account_sid, twilio_api_key_sid, twilio_api_key_secret, identity=identity) token.add_grant(VideoGrant(room=room_name)) data = {'identity': token.identity, 'token': token.to_jwt().decode()} response = {'identity': identity, 'token': token.to_jwt().decode()} return JsonResponse(response)
def token(self, request, pk=None): user = CustomUser.objects.get(pk=pk) token = AccessToken(account_sid, api_key, api_key_secret, identity='user' + str(user.id)) voice_grant = VoiceGrant(outgoing_application_sid=app_sid, push_credential_sid=push_credential_sid, incoming_allow=True) token.add_grant(voice_grant) return HttpResponse(token.to_jwt().decode('utf-8'), )
def connect_video(): username = request.get_json(force=True).get('username') if not username: abort(401) #Initaitve connection by getting the access key token = AccessToken(Config.TWILIO_ACCOUNT_SID, Config.TWILIO_API_KEY, Config.TWILIO_SECRET_KEY, identity=username) token.add_grant(VideoGrant(room='Private Video Call')) return {'token': token.to_jwt().decode()}
def test_conversations_grant(self): scat = AccessToken(ACCOUNT_SID, SIGNING_KEY_SID, 'secret') scat.add_grant(ConversationsGrant(configuration_profile_sid='CP123')) token = scat.to_jwt() assert_is_not_none(token) decoded_token = AccessToken.from_jwt(token, 'secret') self._validate_claims(decoded_token.payload) assert_equal(1, len(decoded_token.payload['grants'])) assert_equal({'configuration_profile_sid': 'CP123'}, decoded_token.payload['grants']['rtc'])
def test_conversations_grant(self): scat = AccessToken(ACCOUNT_SID, SIGNING_KEY_SID, 'secret') scat.add_grant(ConversationsGrant(configuration_profile_sid='CP123')) token = scat.to_jwt() assert_is_not_none(token) decoded_token = AccessToken.from_jwt(token, 'secret') self._validate_claims(decoded_token.payload) assert_equal(1, len(decoded_token.payload['grants'])) assert_equal({ 'configuration_profile_sid': 'CP123' }, decoded_token.payload['grants']['rtc'])
def test_grants(self): scat = AccessToken(ACCOUNT_SID, SIGNING_KEY_SID, 'secret') scat.add_grant(VideoGrant()) scat.add_grant(IpMessagingGrant()) token = scat.to_jwt() assert_is_not_none(token) decoded_token = AccessToken.from_jwt(token, 'secret') self._validate_claims(decoded_token.payload) assert_equal(2, len(decoded_token.payload['grants'])) assert_equal({}, decoded_token.payload['grants']['video']) assert_equal({}, decoded_token.payload['grants']['ip_messaging'])
def test_video_grant(self): scat = AccessToken(ACCOUNT_SID, SIGNING_KEY_SID, 'secret') scat.add_grant(VideoGrant(room='RM123')) token = scat.to_jwt() assert_is_not_none(token) decoded_token = AccessToken.from_jwt(token, 'secret') self._validate_claims(decoded_token.payload) assert_equal(1, len(decoded_token.payload['grants'])) assert_equal({ 'room': 'RM123' }, decoded_token.payload['grants']['video'])
def test_chat_grant(self): scat = AccessToken(ACCOUNT_SID, SIGNING_KEY_SID, 'secret') scat.add_grant(ChatGrant(service_sid='IS123', push_credential_sid='CR123')) token = scat.to_jwt() assert_is_not_none(token) decoded_token = AccessToken.from_jwt(token, 'secret') self._validate_claims(decoded_token.payload) assert_equal(1, len(decoded_token.payload['grants'])) assert_equal({ 'service_sid': 'IS123', 'push_credential_sid': 'CR123' }, decoded_token.payload['grants']['chat'])
def test_sync_grant(self): scat = AccessToken(ACCOUNT_SID, SIGNING_KEY_SID, 'secret') scat.identity = "bender" scat.add_grant(SyncGrant(service_sid='IS123', endpoint_id='blahblahendpoint')) token = scat.to_jwt() assert_is_not_none(token) decoded_token = AccessToken.from_jwt(token, 'secret') self._validate_claims(decoded_token.payload) assert_equal(2, len(decoded_token.payload['grants'])) assert_equal("bender", decoded_token.payload['grants']['identity']) assert_equal({ 'service_sid': 'IS123', 'endpoint_id': 'blahblahendpoint' }, decoded_token.payload['grants']['data_sync'])
def test_programmable_voice_grant_incoming(self): grant = VoiceGrant( incoming_allow=True ) scat = AccessToken(ACCOUNT_SID, SIGNING_KEY_SID, 'secret') scat.add_grant(grant) token = scat.to_jwt() assert_is_not_none(token) decoded_token = AccessToken.from_jwt(token, 'secret') self._validate_claims(decoded_token.payload) assert_equal(1, len(decoded_token.payload['grants'])) assert_equal({ 'incoming': { 'allow': True } }, decoded_token.payload['grants']['voice'])
def token(): # get credentials for environment variables account_sid = os.environ['TWILIO_ACCOUNT_SID'] api_key = os.environ['TWILIO_API_KEY'] api_secret = os.environ['TWILIO_API_SECRET'] # Create an Access Token token = AccessToken(account_sid, api_key, api_secret) # Set the Identity of this token token.identity = fake.user_name() # Grant access to Twilio Video grant = VideoGrant() grant.configuration_profile_sid = os.environ['TWILIO_CONFIGURATION_SID'] token.add_grant(grant) # Return token info as JSON return jsonify(identity=token.identity, token=token.to_jwt())
def token(): # get credentials for environment variables account_sid = os.environ['TWILIO_ACCOUNT_SID'] api_key = os.environ['TWILIO_API_KEY'] api_secret = os.environ['TWILIO_API_SECRET'] service_sid = os.environ['TWILIO_SYNC_SERVICE_SID'] # create a randomly generated username for the client identity = fake.user_name() # Create access token with credentials token = AccessToken(account_sid, api_key, api_secret, identity) # Create a Sync grant and add to token sync_grant = SyncGrant(service_sid=service_sid) token.add_grant(sync_grant) # Return token info as JSON return jsonify(identity=identity, token=token.to_jwt())
def test_task_router_grant(self): grant = TaskRouterGrant( workspace_sid='WS123', worker_sid='WK123', role='worker' ) scat = AccessToken(ACCOUNT_SID, SIGNING_KEY_SID, 'secret') scat.add_grant(grant) token = scat.to_jwt() assert_is_not_none(token) decoded_token = AccessToken.from_jwt(token, 'secret') self._validate_claims(decoded_token.payload) assert_equal(1, len(decoded_token.payload['grants'])) assert_equal({ 'workspace_sid': 'WS123', 'worker_sid': 'WK123', 'role': 'worker' }, decoded_token.payload['grants']['task_router'])
def token(): # get credentials for environment variables account_sid = os.environ['TWILIO_ACCOUNT_SID'] api_key = os.environ['TWILIO_API_KEY'] api_secret = os.environ['TWILIO_API_SECRET'] service_sid = os.environ['TWILIO_CHAT_SERVICE_SID'] # create a randomly generated username for the client identity = fake.user_name() # Create a unique endpoint ID for the device_id = request.args.get('device') endpoint = "TwilioChatDemo:{0}:{1}".format(identity, device_id) # Create access token with credentials token = AccessToken(account_sid, api_key, api_secret, identity=identity) # Create a Chat grant and add to token chat_grant = ChatGrant(endpoint_id=endpoint, service_sid=service_sid) token.add_grant(chat_grant) # Return token info as JSON return jsonify(identity=identity, token=token.to_jwt())
def test_programmable_voice_grant(self): grant = VoiceGrant( outgoing_application_sid='AP123', outgoing_application_params={ 'foo': 'bar' } ) scat = AccessToken(ACCOUNT_SID, SIGNING_KEY_SID, 'secret') scat.add_grant(grant) token = scat.to_jwt() assert_is_not_none(token) decoded_token = AccessToken.from_jwt(token, 'secret') self._validate_claims(decoded_token.payload) assert_equal(1, len(decoded_token.payload['grants'])) assert_equal({ 'outgoing': { 'application_sid': 'AP123', 'params': { 'foo': 'bar' } } }, decoded_token.payload['grants']['voice'])
def test_add_grant_validates_grant(self): scat = AccessToken(ACCOUNT_SID, SIGNING_KEY_SID, 'secret') scat.add_grant(VideoGrant()) self.assertRaises(ValueError, scat.add_grant, 'GrantRootAccess')
from twilio.jwt.access_token import AccessToken from twilio.jwt.access_token.grants import VideoGrant # Required for all Twilio Access Tokens account_sid = 'ACxxxxxxxxxxxx' api_key = 'SKxxxxxxxxxxxx' api_secret = 'xxxxxxxxxxxxxx' # required for Video grant identity = 'user' # Create Access Token with credentials token = AccessToken(account_sid, api_key, api_secret, identity=identity) # Create a Video grant and add to token video_grant = VideoGrant(room='cool room') token.add_grant(video_grant) # Return token info as JSON print(token.to_jwt())
from twilio.jwt.access_token import AccessToken, IpMessagingGrant # required for all twilio access tokens account_sid = 'ACxxxxxxxxxxxx' api_key = 'SKxxxxxxxxxxxx' api_secret = 'xxxxxxxxxxxxxx' # required for IP messaging grants ipm_service_sid = 'ISxxxxxxxxxxxx' identity = '*****@*****.**' device_id = 'someiosdevice' endpoint_id = "HipFlowSlackDockRC:{0}:{1}".format(identity, device_id) # Create access token with credentials token = AccessToken(account_sid, api_key, api_secret, identity) # Create an IP Messaging grant and add to token ipm_grant = IpMessagingGrant( endpoint_id=endpoint_id, service_sid=ipm_service_sid) token.add_grant(ipm_grant) # Return token info as JSON print(token.to_jwt())
from twilio.jwt.access_token import AccessToken, VoiceGrant # required for all twilio access tokens account_sid = 'ACxxxxxxxxxxxx' api_key = 'SKxxxxxxxxxxxx' api_secret = 'xxxxxxxxxxxxxx' # required for Voice grant outgoing_application_sid = 'APxxxxxxxxxxxxx' identity = 'user' # Create access token with credentials token = AccessToken(account_sid, api_key, api_secret, identity) # Create a Voice grant and add to token voice_grant = VoiceGrant( outgoing_application_sid=outgoing_application_sid ) token.add_grant(voice_grant) # Return token info as JSON print(token.to_jwt())
from twilio.jwt.access_token import AccessToken from twilio.jwt.access_token.grants import ChatGrant # required for all twilio access tokens account_sid = 'ACxxxxxxxxxxxx' api_key = 'SKxxxxxxxxxxxx' api_secret = 'xxxxxxxxxxxxxx' # required for Chat grants service_sid = 'ISxxxxxxxxxxxx' identity = '*****@*****.**' device_id = 'someiosdevice' endpoint_id = "HipFlowSlackDockRC:{0}:{1}".format(identity, device_id) # Create access token with credentials token = AccessToken(account_sid, api_key, api_secret, identity=identity) # Create an Chat grant and add to token chat_grant = ChatGrant(endpoint_id=endpoint_id, service_sid=service_sid) token.add_grant(chat_grant) # Return token info as JSON print(token.to_jwt())