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 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 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 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(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_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 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 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 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 test_empty_grants(self):
scat = AccessToken(ACCOUNT_SID, SIGNING_KEY_SID, 'secret')
token = scat.to_jwt()
assert_is_not_none(token)
decoded_token = AccessToken.from_jwt(token, 'secret')
self._validate_claims(decoded_token.payload)
assert_equal({}, decoded_token.payload['grants'])
def test_empty_grants(self):
scat = AccessToken(ACCOUNT_SID, SIGNING_KEY_SID, 'secret')
token = scat.to_jwt()
assert_is_not_none(token)
decoded_token = AccessToken.from_jwt(token, 'secret')
self._validate_claims(decoded_token.payload)
assert_equal({}, decoded_token.payload['grants'])
def token():
token = AccessToken(
os.environ['TWILIO_ACCOUNT_SID'],
os.environ['TWILIO_API_KEY_SID'],
os.environ['TWILIO_API_KEY_SECRET'],
grants=[SyncGrant(os.environ['TWILIO_SYNC_SERVICE_SID'])],
identity=uuid.uuid4().hex)
return {'token': token.to_jwt().decode()}
def test_region(self):
scat = AccessToken(ACCOUNT_SID,
SIGNING_KEY_SID,
'secret',
region='foo')
token = scat.to_jwt()
decoded_token = AccessToken.from_jwt(token, 'secret')
assert_equal(decoded_token.headers['twr'], 'foo')
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 test_nbf(self):
now = int(time.mktime(datetime.now().timetuple()))
scat = AccessToken(ACCOUNT_SID, SIGNING_KEY_SID, 'secret', nbf=now)
token = scat.to_jwt()
assert_is_not_none(token)
decoded_token = AccessToken.from_jwt(token, 'secret')
self._validate_claims(decoded_token.payload)
assert_equal(now, decoded_token.nbf)
def test_nbf(self):
now = int(time.mktime(datetime.now().timetuple()))
scat = AccessToken(ACCOUNT_SID, SIGNING_KEY_SID, 'secret', nbf=now)
token = scat.to_jwt()
assert_is_not_none(token)
decoded_token = AccessToken.from_jwt(token, 'secret')
self._validate_claims(decoded_token.payload)
assert_equal(now, decoded_token.nbf)
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 test_identity(self):
scat = AccessToken(ACCOUNT_SID, SIGNING_KEY_SID, 'secret', identity='*****@*****.**')
token = scat.to_jwt()
assert_is_not_none(token)
decoded_token = AccessToken.from_jwt(token, 'secret')
self._validate_claims(decoded_token.payload)
assert_equal({
'identity': '*****@*****.**'
}, decoded_token.payload['grants'])
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 __init__(self, user, room):
# Create access token with credentials
self.token = AccessToken(account_sid,
api_key,
api_secret,
identity=user)
# Create a Video grant and add to token
video_grant = VideoGrant(room=room)
self.token.add_grant(video_grant)
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 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 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 generateToken(identity):
# 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']
sync_service_sid = os.environ.get('TWILIO_SYNC_SERVICE_SID', 'default')
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 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 Video grant and add to token
video_grant = VideoGrant()
token.add_grant(video_grant)
# 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 jsonify(identity=identity, token=token.to_jwt().decode('utf-8'))
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']
sync_service_sid = os.environ['TWILIO_SYNC_SERVICE_SID']
chat_service_sid = os.environ['TWILIO_CHAT_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=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 Video grant and add to token
video_grant = VideoGrant()
token.add_grant(video_grant)
# Create an Chat grant and add to token
if chat_service_sid:
chat_grant = IpMessagingGrant(service_sid=chat_service_sid)
token.add_grant(chat_grant)
# Return token info as JSON
return jsonify(identity=identity, token=token.to_jwt().decode('utf-8'))
def test_conversations_grant(self):
scat = AccessToken(ACCOUNT_SID, SIGNING_KEY_SID, 'secret')
scat.add_grant(ConversationsGrant(configuration_profile_sid='CP123'))
token = str(scat)
assert_is_not_none(token)
payload = decode(token, 'secret')
self._validate_claims(payload)
assert_equal(1, len(payload['grants']))
assert_equal({'configuration_profile_sid': 'CP123'},
payload['grants']['rtc'])
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_SID)
token.add_grant(sync_grant)
# Return token info as JSON
return jsonify(identity=identity, token=token.to_jwt().decode('utf-8'))
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 start_call(request):
user_name = json.loads(request.body.decode("utf-8")).get('user_name')
room_name = json.loads(request.body.decode("utf-8")).get('room_name')
token = AccessToken(twilio_account_sid,
twilio_api_key_sid,
twilio_api_key_secret,
identity=user_name)
token.add_grant(VideoGrant(room=room_name))
# token.add_grant(VideoGrant(room=username_caller + '_' + username_callee))
return JsonResponse({'token': token.to_jwt().decode()})
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_identity(self):
scat = AccessToken(ACCOUNT_SID,
SIGNING_KEY_SID,
'secret',
identity='*****@*****.**')
token = scat.to_jwt()
assert_is_not_none(token)
decoded_token = AccessToken.from_jwt(token, 'secret')
self._validate_claims(decoded_token.payload)
assert_equal({'identity': '*****@*****.**'},
decoded_token.payload['grants'])
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_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_pass_grants_in_constructor(self):
grants = [
VideoGrant(),
IpMessagingGrant()
]
scat = AccessToken(ACCOUNT_SID, SIGNING_KEY_SID, 'secret', grants=grants)
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_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']
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 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 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 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 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_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'])
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 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())
def test_headers(self):
scat = AccessToken(ACCOUNT_SID, SIGNING_KEY_SID, 'secret')
token = scat.to_jwt()
assert_is_not_none(token)
decoded_token = AccessToken.from_jwt(token, 'secret')
self.assertEqual(decoded_token.headers['cty'], 'twilio-fpa;v=1')
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())
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 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())
