def create():
if request.method == 'POST':
content = request.get_json(silent=True)
fullName = cgi.escape(content['username'])
className = cgi.escape(content['classname'])
hashids = Hashids(salt=settings.HASHID_SALT,min_length=6)
increment()
count = get_count()
hashid = hashids.encode(count)
courseId = DEFAULT_COURSE_PREFIX + hashid
userId = request.cookies.get('remote_userid') if 'remote_userid' in request.cookies else generate_user_id()
userColor = request.cookies.get('remote_usercolor') if 'remote_usercolor' in request.cookies else generate_color()
host = app.config.get('host')
resp = make_response(hashid)
# Add course to database
key = courseId
course = Course.get_or_insert(key, courseId=courseId, teacherName=fullName)
course.put()
# Add teacher to course
# Create OpenTok session
opentok_sdk = OpenTok(OPENTOK_API_KEY, OPENTOK_API_SECRET)
# use tokbox server to route media streams;
# if you want to use p2p - change media_mode to MediaModes.relayed
opentok_session = opentok_sdk.create_session(media_mode = MediaModes.routed)
opentok_token = opentok_sdk.generate_token(opentok_session.session_id)
key = courseId + userId
user = Student.get_or_insert(key,
courseId = courseId,
studentId = userId,
fullName = fullName,
color = userColor,
role = 'TEACHER',
opentokSessionId = opentok_session.session_id,
opentokToken = opentok_token
)
user.put()
# Set user cookies (teacher role)
auth = json.loads(request.cookies.get('remote_auth')) if 'remote_auth' in request.cookies else {}
auth[hashid] = {
'role': 'Instructor',
'opentok_api_key': OPENTOK_API_KEY,
'opentok_session_id': user.opentokSessionId,
'opentok_token': user.opentokToken
}
resp.set_cookie('remote_userfullname', fullName)
resp.set_cookie('remote_auth', json.dumps(auth))
resp.set_cookie('remote_userid', userId)
resp.set_cookie('remote_usercolor', userColor)
#resp.set_cookie('remote_userinitials', userInitials)
return resp
return redirect('/main#/create')
def __init__(self):
config = ConfigParser()
config.read('config.ini')
opentok_api_key = config.get('tokens', 'opentok_api_key')
opentok_api_secret = config.get('tokens', 'opentok_api_secret')
self.opentok = OpenTok(opentok_api_key, opentok_api_secret)
self.session = None
def post(self):
caller = self.request.get('caller')
callee = self.request.get('callee')
registrations = Registration.query(
Registration.uid == callee).order(-Registration.date).fetch(5)
opentok = OpenTok(api_key, secret)
session = opentok.create_session()
token = session.generate_token()
call = {
'caller': caller,
'callee': callee,
'apiKey': api_key,
'sessionId': session.session_id,
'token': token
}
if not registrations:
self.abort(404)
return
logging.info(str(registrations))
for registration in registrations:
self.signal(registration.session_id, call)
self.response.write(json.dumps(call))
def create_interview_session():
if settings.ENVIRONMENT != "TEST":
opentok = OpenTok(settings.OPENTOK_API_KEY,
settings.OPENTOK_SECRET)
session = opentok.create_session(media_mode=MediaModes.relayed)
return session.session_id
return "UNKNOWN"
def setUp(self):
self.api_key = u('123456')
self.api_secret = u('1234567890abcdef1234567890abcdef1234567890')
self.session_id = u(
'1_MX4xMjM0NTZ-flNhdCBNYXIgMTUgMTQ6NDI6MjMgUERUIDIwMTR-MC40OTAxMzAyNX4'
)
self.opentok = OpenTok(self.api_key, self.api_secret)
def create_session(request):
tbox = TokBox.objects.get(pk=1)
opentok = OpenTok(tbox.api_key, tbox.api_secret)
session = opentok.create_session(media_mode=MediaModes.routed)
session_id = session.session_id
return HttpResponse(session_id)
def get_context_data(self, **kwargs):
#room = "333"
api_key = '47058394'
api_secret = '6a0bd6f70f9be22bde0678e0ae81f8d608e5aea1'
#print(self.request.GET.get('room',))
context = super(OpenRoom, self).get_context_data(**kwargs)
opentok = OpenTok(api_key, api_secret)
if context['room'] == 3:
session_id = Event.objects.get_sala(2)
token = opentok.generate_token(session_id[0].token,
role=Roles.publisher)
else:
session_id = Event.objects.get_sala(context['room'])
token = opentok.generate_token(session_id[0].token)
print(token)
#context=super(OpenRoom,self).get_context_data(**kwargs)
context['api_key'] = '47058394'
context['session_id'] = session_id[0].token
context['token'] = token
return context
def get_opentok_details(opentok_session_id, chat_time=0):
optok = Opentok.objects.filter(mode='development').first()
opentok = OpenTok(optok.api_key, optok.api_secret)
token = opentok.generate_token(opentok_session_id)
api_key = Opentok.get_api_key()
session_id = opentok_session_id
return token, api_key, session_id
def save(self, *args, **kwargs):
opentok = OpenTok('46764812',
'c6376c5a1c8c5c7c40d97235d852d6d50698e1a3')
session = opentok.create_session()
self.token = session.generate_token()
self.session = session.session_id
super(Room, self).save(*args, **kwargs)
def setUp(self):
self.api_key = u('123456')
self.api_secret = u('1234567890abcdef1234567890abcdef1234567890')
self.opentok = OpenTok(self.api_key, self.api_secret)
self.session_id = u('SESSIONID')
self.token = u('TOKEN')
self.sip_uri = u('sip:[email protected];transport=tls')
def gen_token(request, session_pk=None):
# make curl to create session
# requrl = request.build_absolute_uri(reverse("tbox:create_session"))
# req = urllib2.Request(requrl)
# res = urllib2.urlopen(req)
# session_id = res.read()
# GET has to pass the session_pk or passed from room view
if request.method == "GET" or session_pk:
res = {}
if request.GET or session_pk:
if request.GET:
session = Session.objects.get(pk=request.GET["session_pk"])
else:
session = Session.objects.get(pk=session_pk)
session_id = session.session_id
print "token request for session and session id:"
print session, session_id
tbox = TokBox.objects.get(pk=1)
opentok = OpenTok(tbox.api_key, tbox.api_secret)
#set token parameters: role and data
print "request by user:"******"role": None, "data": "name=" + request.user.username}
if userprofile.function == "Mod":
params["role"] = Roles.moderator
elif userprofile.function == "Pub":
params["role"] = Roles.publisher
elif userprofile.function == "Sub":
params["role"] = Roles.subscriber
token = opentok.generate_token(session_id, **params)
print token
res["token"] = token
res["success"] = {
"status": True,
"error": None,
}
if request.GET:
return HttpResponse(json.dumps(res))
else:
return json.dumps(res)
else:
res["success"] = {
"status": False,
"error": "no GET data",
}
return HttpResponse(json.dumps(res))
elif request.method == "POST":
# need to update session table with connection count
# need to update connection table with connection id and data
# will be done through ajax post/tokbox js on room view
pass
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
try:
api_key = os.environ['API_KEY']
api_secret = os.environ['API_SECRET']
except Exception:
raise RuntimeError('You must define API_KEY and API_SECRET environment variables')
self.opentok = OpenTok(api_key, api_secret)
self.sessions = dict()
self.users = dict()
def game(sid):
opentok = OpenTok(api_key, api_secret)
session_id = unicode(sid)
token = opentok.generate_token(session_id)
session = Session.query.filter_by(s_id=sid).first()
if session.player1 == None:
session.player1 = token
else:
session.player2 = token
db.session.commit() #db session, don't confuse with tb session
return render_template('game.html', token=token, sid=session_id)
def add_ot_session(api_key, api_session):
from opentok import OpenTok
opentok = OpenTok(api_key, api_session)
otsession = opentok.create_session()
otsessiondb.insert_one({
"_id": otsession.session_id,
"timestamp": time.time(),
"status": "open"
})
return 200
def get(self, request, *args, **kwargs):
opentok = OpenTok(
settings.API_KEY,
settings.API_SECRET)
session_id = kwargs.get('session_id')
response = {
'api_key': settings.API_KEY,
'token': opentok.generate_token(session_id)
}
return JsonResponse(
response, content_type="application/json", safe=False)
def get(self, request, *args, **kwargs):
opentok = OpenTok('46640082',
'27254ec0aeb2fb70021007f55c9dfb26078b727d')
session = opentok.create_session()
session_id = session.session_id
token = session.generate_token()
return JsonResponse({
"ar_session_id": session_id,
"ar_token": token
},
safe=False)
class Tokbox(object):
opentok = OpenTok(OPENTOK_API_KEY, OPENTOK_API_SECRET)
def create_session(self, *args, **kwargs):
return self.opentok.create_session()
def get_token(self, session):
return session.generate_token(
role=Roles.moderator,
expire_time=int(time.time()) + 10,
data=u'name=Johnny',
initial_layout_class_list=[u'focus'])
def video(classId):
if "userId" in session:
if request.method == "POST":
api_key = '46838544'
api_secret = 'c727ac0672a3ae6c1490b68e4032d8e982531450'
opentok = OpenTok(api_key, api_secret)
session_id = classdb.find_one({"_id": ObjectId(classId)}, {"session_id": 1})["session_id"]
Tk = opentok.generate_token(session_id)
# Sending Video API credentials
return jsonify({'apiKey': api_key, 'sessionId': session_id, 'token': Tk})
return render_template('class.html')
def get(self, request, *args, **kwargs):
opentok = OpenTok(
settings.API_KEY,
settings.API_SECRET)
session = opentok.create_session(
media_mode=MediaModes.routed,
archive_mode=ArchiveModes.always)
response = {
'session_id': session.session_id,
'api_key': settings.API_KEY,
'token': opentok.generate_token(session.session_id)
}
return JsonResponse(
response, content_type="application/json", safe=False)
def join():
content = request.get_json(silent=True)
hashid = cgi.escape(content['hashid'])
fullName = cgi.escape(content['username'])
userId = request.cookies.get('remote_userid') if 'remote_userid' in request.cookies else generate_user_id()
userColor = request.cookies.get('remote_usercolor') if 'remote_usercolor' in request.cookies else generate_color()
resp = make_response(hashid)
# Ensure course exists
courseId = DEFAULT_COURSE_PREFIX + hashid
course = ndb.Key('Course', courseId).get()
# Add user to course
key = courseId + userId
user = Student.get_or_insert(key, courseId=courseId, studentId=userId, fullName=fullName, color=userColor)
userInitials = user.initials
user.put()
if not user.opentokSessionId:
opentok_sdk = OpenTok(OPENTOK_API_KEY, OPENTOK_API_SECRET)
# use tokbox server to route media streams;
# if you want to use p2p - change media_mode to MediaModes.relayed
opentok_session = opentok_sdk.create_session(media_mode = MediaModes.routed)
opentok_token = opentok_sdk.generate_token(opentok_session.session_id)
user.opentokSessionId = opentok_session.session_id
user.opentokToken = opentok_token
user.put()
teacher = Student.get_teacher_by_course(courseId)
# Set user cookies (student role)
auth = json.loads(request.cookies.get('remote_auth')) if 'remote_auth' in request.cookies else {}
auth[hashid] = {
'role': 'Student',
'opentok_api_key': OPENTOK_API_KEY,
'opentok_session_id': user.opentokSessionId,
'opentok_token': user.opentokToken,
'teacher_session_id': teacher.opentokSessionId,
'teacher_token': teacher.opentokToken
}
resp.set_cookie('remote_userfullname', fullName)
resp.set_cookie('remote_auth', json.dumps(auth))
resp.set_cookie('remote_userid', userId)
resp.set_cookie('remote_usercolor', userColor)
resp.set_cookie('remote_userinitials', userInitials)
configChanged(courseId, 'config', 'users')
return resp
def post(self, request, *args, **kwargs):
api_key = '47058394'
api_secret = '6a0bd6f70f9be22bde0678e0ae81f8d608e5aea1'
opentok = OpenTok(api_key, api_secret)
session = opentok.create_session()
session_id = session.session_id
token = opentok.generate_token(session_id)
Event.objects.create_token(request.POST['id'], session_id)
#logout(request)
return HttpResponseRedirect(reverse('induccion_app:entry-lista'))
def index():
sid = ''
sessions = Session.query.all()
for s in sessions:
if (s.player1 == None or s.player2 == None):
sid = s.s_id
if sid == '':
opentok = OpenTok(api_key, api_secret)
session = opentok.create_session()
sid = session.session_id
unicodedata.normalize('NFKD', sid).encode('ascii', 'ignore')
s = Session(s_id=sid, player1=None, player2=None)
db.session.add(s)
db.session.commit()
return redirect('/game/' + sid)
def get_context_data(self, **kwargs):
InterviewRoomViewExperiment.test = not InterviewRoomViewExperiment.test
context = super(InterviewRoomViewExperimentEE,
self).get_context_data(**kwargs)
opentok = OpenTok(settings.OPENTOK_API_KEY, settings.OPENTOK_SECRET)
context['test'] = self.test
context['is_interview_open'] = True
context['api_key'] = settings.OPENTOK_API_KEY
context[
'session_id'] = "1_MX40NTExOTk3Mn5-MTQyMDI3NzYxMzI1NH5zek80L1owVkRadGVRMS9peUZQR2dKa0l-UH4"
context['role'] = "interviewee"
context['token'] = opentok.generate_token(
session_id=context['session_id'],
data="test=" + str(InterviewRoomViewExperiment.test),
role=Roles.publisher)
return context
def create_app(env):
init_config(env)
app = _initialize_flask_app()
app.wsgi_app = RequestLoggerMiddleware(app.wsgi_app)
app = _configure_logging(app)
app.config.from_object(Ivysaur.Config)
app = _register_blueprints(app)
app = _register_version_and_log(app)
db = SQLAlchemy(app, session_options={"autoflush": False})
reg = get_registry()
reg['DB'] = db
mail = Mail(app)
reg['MAIL'] = mail
reg['TOKBOX'] = OpenTok(
Ivysaur.Config.TOKBOX_API_KEY, Ivysaur.Config.TOKBOX_API_SECRET
)
from lib.models.user import User
from lib.models.role import Role
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
Security(app, user_datastore)
from lib.repo.user_repo import UserRepo
from lib.repo.device_repo import DeviceRepo
from lib.repo.deck_repo import DeckRepo
from lib.repo.notification_repo import NotificationRepo
from lib.repo.ask_repo import AskRepo
# see comment for this method
_initialize_models()
reg['USER_DATASTORE'] = user_datastore
reg['USER_REPO'] = UserRepo()
reg['DEVICE_REPO'] = DeviceRepo()
reg['DECK_REPO'] = DeckRepo()
reg['NOTIFICATION_REPO'] = NotificationRepo()
reg['ASK_REPO'] = AskRepo()
app = _initialize_managers(app)
app.json_encoder = AppJSONEncoder
return app
def admin_class():
if profiledb.find_one({"_id": ObjectId(session["userId"])})["role"] == "admin":
query = request.form
api_key = '46838544'
api_secret = 'c727ac0672a3ae6c1490b68e4032d8e982531450'
opentok = OpenTok(api_key, api_secret)
video_session = opentok.create_session()
classdb.insert_one({
"title": query["title"],
"body": query["body"],
"session_id": video_session.session_id
})
return redirect(url_for('profile', id=profiledb.find_one({"role": "admin"})["_id"]))
"""Only one endpoint for long polling"""
def get(self, request, *args, **kwargs):
opentok = OpenTok(
settings.API_KEY,
settings.API_SECRET)
response = opentok.get_archive(kwargs.get('archive_id'))
millis = int(response.duration)
seconds = (millis / 1000) % 60
seconds = int(seconds)
minutes = (millis / (1000 * 60)) % 60
minutes = int(minutes)
hours = (millis / (1000 * 60 * 60)) % 24
response = {
"url": response.url,
"status": response.status,
"api_key": settings.API_KEY,
"length": str(hours) + " : " + str(minutes) + " : " + str(seconds)}
return JsonResponse(
response, content_type="application/json", safe=False)
def add_meeting(request):
api_key = "47084204" # Replace with your OpenTok API key.
api_secret = "3e487ed7f77e32f86f561244ee1571618a485458" # Replace with your OpenTok API secret.
data = request.data
opentok = OpenTok(api_key, api_secret)
session = opentok.create_session()
session_id = session.session_id
token = opentok.generate_token(session_id)
meeting = Meeting(name=data['name'],
session_id=session_id,
token=token,
start_date=data['start_date'],
end_date=data['end_date'],
colour=data['colour'],
summary=data['summary'],
fullday=data['fullday'])
meeting.save()
return Response(meeting.values())
def get(self):
template = JINJA_ENVIRONMENT.get_template('index.html')
uid = self.request.get('uid')
if uid:
opentok = OpenTok(api_key, secret)
session = opentok.create_session()
registration = Registration(parent=ndb.Key('Registration', 'poc'))
registration.uid = uid
registration.session_id = str(session.session_id)
registration.put()
logging.info('Register uid: ' + uid + ' sessionId: ' +
session.session_id)
self.response.write(
template.render({
'uid': uid,
'apiKey': api_key,
'sessionId': session.session_id,
'token': session.generate_token()
}))
else:
self.response.write(template.render({}))
from flask import Flask
from flask.ext.bcrypt import Bcrypt
from flask.ext.login import LoginManager
from flask_mail import Mail
from flask.ext.sqlalchemy import SQLAlchemy
from opentok import OpenTok
app = Flask(__name__)
app.config.from_object('config')
login_manager = LoginManager()
login_manager.init_app(app)
bcrypt = Bcrypt(app)
mail = Mail(app)
db = SQLAlchemy(app)
opentok_sdk = OpenTok(app.config['OT_API_KEY'], app.config['OT_API_SECRET'])
from project.main.views import main_blueprint
from project.user.views import user_blueprint
from project.category.views import category_blueprint
from project.webinar.views import webinar_blueprint
app.register_blueprint(main_blueprint)
app.register_blueprint(user_blueprint)
app.register_blueprint(category_blueprint)
app.register_blueprint(webinar_blueprint)
from project.models import User, Category, Webinar
login_manager.login_view = "user.login"
login_manager.login_message_category = "danger"
from rest_framework import permissions, viewsets, mixins, generics
from rest_framework.response import Response
from .models import VedioChat, video_chat_session
from .serializers import VedioChatSerializer, video_mobile_serializer
from doctors.models import doctors_info
from patients.models import patient_info
from appointment.models import appointment as appo
from consultations.models import consultations
from rest_framework import status
from opentok import OpenTok
from django.utils import timezone
opentok = OpenTok("47034434", "21f8951c03ab3c4f33eba0962905212594f477e5")
class vedioChatOparetion(viewsets.ModelViewSet):
permission_classes = [permissions.AllowAny]
serializer_class = VedioChatSerializer
def get_queryset(self):
queryset = VedioChat.objects.filter(is_answered=False)
user = self.request.query_params.get('user', None)
if user is not None:
queryset = self.request.user.call_for.filter(is_answered=False)
return queryset
def perform_create(self, serializer):
return serializer.save()
class MobVedioChatOparetion(viewsets.ModelViewSet):
permission_classes = [permissions.IsAuthenticated]
