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 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 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_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 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 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 video(post_data):
"""
Creates JWT Twlio Room token
Request:
appointmentId: string
hcpToken: string?
patientToken: string?
Response:
token: videoId
id: AppointmentId
date: number
duration: number
doctor: DoctorId
patient: PatientId
subject: string
"""
auth_token = post_data.get('token')
if auth_token:
pid, _ = Auth.decode_auth_token(auth_token)
appointment_id = post_data.get('appointmentId')
appointments_output = appointmentsdb.document(
str(appointment_id)).get().to_dict()
if not (pid == appointments_output['patient']
or pid == appointments_output['doctor']):
response_object = {
"Success": False,
"message": "ID not in appointment, unable to access room"
}
return response_object, 401
conversation = get_chatroom(str(appointment_id))
try:
conversation.participants.create(identity=pid)
except TwilioRestException as exc:
# do not error if the user is already in the conversation
if exc.status != 409:
raise
token = twilio.access_token(pid)
token.add_grant(VideoGrant(room=str(appointment_id)))
token.add_grant(ChatGrant(service_sid=conversation.chat_service_sid))
response_object = {
"accessToken": token.to_jwt().decode(),
"id": appointments_output['id'],
"date": appointments_output['date'],
"duration": appointments_output['duration'],
"doctor": appointments_output['doctor'],
"patient": appointments_output['patient'],
"subject": appointments_output['subject'],
"notes": appointments_output['notes']
}
return response_object, 200
else:
response_object = {
'Success': False,
'message': 'Failed to verify role'
}
return response_object, 401
def login():
username = request.get_json(force=True).get('username')
room = request.get_json(force=True).get('room')
if not username:
abort(401)
conversation = get_chatroom(room)
try:
conversation.participants.create(identity=username)
except TwilioRestException as exc:
# do not error if the user is already in the conversation
if exc.status != 409:
raise
token = AccessToken(twilio_account_sid,
twilio_api_key_sid,
twilio_api_key_secret,
identity=username)
token.add_grant(VideoGrant(room=room))
token.add_grant(ChatGrant(service_sid=conversation.chat_service_sid))
return {
'token': token.to_jwt().decode(),
'conversation_sid': conversation.sid
}
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 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 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'))
token.add_grant(ChatGrant(service_sid=twilio_chat_service_sid))
return {'token': token.to_jwt().decode()}
def getToken():
identity = request.query.get('identity')
if identity == '':
response.status = 400
return 'getToken requires an Identity to be provided'
# 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(service_sid=service_sid)
token.add_grant(chat_grant)
return (token.to_jwt())
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 login():
payload = request.get_json(force=True)
username = payload.get('username')
if not username:
abort(401)
# create the user (if it does not exist yet)
participant_role_sid = None
for role in twilio_client.conversations.roles.list():
if role.friendly_name == 'participant':
participant_role_sid = role.sid
try:
twilio_client.conversations.users.create(identity=username,
role_sid=participant_role_sid)
except TwilioRestException as exc:
if exc.status != 409:
raise
# add the user to all the conversations
conversations = twilio_client.conversations.conversations.list()
for conversation in conversations:
try:
conversation.participants.create(identity=username)
except TwilioRestException as exc:
if exc.status != 409:
raise
# generate an access token
twilio_account_sid = os.environ.get('TWILIO_ACCOUNT_SID')
twilio_api_key_sid = os.environ.get('TWILIO_API_KEY_SID')
twilio_api_key_secret = os.environ.get('TWILIO_API_KEY_SECRET')
service_sid = conversations[0].chat_service_sid
token = AccessToken(twilio_account_sid,
twilio_api_key_sid,
twilio_api_key_secret,
identity=username)
token.add_grant(ChatGrant(service_sid=service_sid))
# send a response
return {
'chatrooms': [[conversation.friendly_name, conversation.sid]
for conversation in conversations],
'token':
token.to_jwt().decode(),
}
def get_chat_token(username):
logger.info('Generating Chat token for {}'.format(username))
# This call is simply to ensure the service exists, though it is not needed to generate token
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)
return token.to_jwt()
def make_messaging_token(self, user_id, uuid):
try:
identity = str(user_id)
# Create access token with credentials
token = AccessToken(self._account_sid,
self._api_key,
self._api_secret,
identity=identity)
# Create an Chat grant and add to token
chat_grant = ChatGrant(
service_sid=self._chat_service_sid,
push_credential_sid=self._push_credential_sid)
token.add_grant(chat_grant)
return token.to_jwt().decode('utf-8')
except Exception as ex:
logging.error('make_messaging_token failed, {}'.format(ex))
raise APIInternalServicesError('make_messaging_token failed')
def token(request):
if request.method == 'POST':
body = json.loads(request.body)
username = body['username']
conversation = get_chatroom('My Room')
try:
conversation.participants.create(identity=username)
except TwilioRestException as exc:
# do not error if the user is already in the conversation
if exc.status != 409:
raise
token = AccessToken(account_sid,
api_sid,
api_secret,
identity=username)
token.add_grant(VideoGrant(room='My Room'))
token.add_grant(ChatGrant(service_sid=conversation.chat_service_sid))
return JsonResponse({'token': token.to_jwt().decode('utf-8')})
def token(request):
identity = request.user.username
device_id = request.GET.get('device', 'default')
account_sid = 'AC9aad7718f64dfb7e31c8dabb56c1e308'
api_key = 'SKb5e2d2a54657675a6d11c483bb5ca90a'
api_secret = '6Mlikb507Fb6STGFrkyKUAb0BjuWaMl3'
chat_service_sid = 'ISa9d87f39b3c14f75b2a40a805e70cd5f'
token = AccessToken(account_sid, api_key, api_secret, identity=identity)
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 token(request):
""""""
identity = request.GET.get("identity", request.user.username)
device_id = request.GET.get("device", "default")
account_sid = settings.TWILIO_ACCOUNT_SID
api_key = settings.TWILIO_API_KEY_SID
api_secret = settings.TWILIO_API_KEY_SECRET
chat_service_sid = settings.TWILIO_CHAT_SERVER_SID
token = AccessToken(account_sid, api_key, api_secret, identity=identity)
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 token(request):
from_user_id = request.GET.get('from_user_id', None)
to_user_id = request.GET.get('to_user_id', None)
device_id = request.GET.get('device', 'default') # unique device ID
from_user_name = User.objects.get(id=from_user_id).first_name
to_user_name = User.objects.get(id=to_user_id).first_name
room_id = min(from_user_id, to_user_id) + "--" + \
max(from_user_id, to_user_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=from_user_name)
# Create a unique endpoint ID for the device
endpoint = "MyDjangoChatRoom:{0}:{1}".format(room_id, device_id)
if chat_service_sid:
chat_grant = ChatGrant(endpoint_id=endpoint,
service_sid=chat_service_sid)
token.add_grant(chat_grant)
response = {
'from_user_name': from_user_name,
'to_user_name': to_user_name,
'identity': room_id,
'token': token.to_jwt().decode('utf-8')
}
print("Response: ", response)
return JsonResponse(response)
def generate_video_token():
# current_user = get_jwt_identity()
# required for all twilio access tokens
account_sid = os.getenv('TWILIO_ACCOUNT_SID')
api_key = os.getenv('TWILIO_API_KEY')
api_secret = os.getenv('TWILIO_API_SECRET')
service_id = os.getenv('TWILIO_SERVICE_ID')
identity = request.json.get('identity')
# 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()
chat_grant = ChatGrant(service_id)
token.add_grant(video_grant)
token.add_grant(chat_grant)
# Return token info as JSON
return jsonify({'token': token.to_jwt().decode()})
def generateToken(identity):
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)
token = AccessToken(account_sid, api_key, api_secret, identity=identity)
# we sync here, according to tutorial. not too sure what it does
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, we basically add chat services for the user
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())
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())
import os from twilio.jwt.access_token import AccessToken from twilio.jwt.access_token.grants import ChatGrant # required for all twilio access tokens # To set up environmental variables, see http://twil.io/secure account_sid = os.environ['TWILIO_ACCOUNT_SID'] api_key = os.environ['TWILIO_API_KEY'] api_secret = os.environ['TWILIO_API_KEY_SECRET'] # required for Chat grants service_sid = 'ISxxxxxxxxxxxx' identity = '*****@*****.**' # 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(service_sid=service_sid) token.add_grant(chat_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())
from twilio.jwt.access_token.grants import ChatGrant
endpoint = 'https://some.endpoint'
service_sid = 'ISXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
grant = ChatGrant(endpoint_id=endpoint,
service_sid=service_sid,
push_credential_sid='CRXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')
