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]