exports.joinInterview = function (interviewId, participantId, callback) {
var token = ot.generateToken({
connection_data: participantId,
role: 'publisher'
});
var interview = interviews[interviewId];
if (interview) { // Interview exists
interview.drafts[participantId] = interview.source;
callback(interview, token);
return;
}
// Creating new interview and TB session
var source = fs.readFileSync('default.html', 'utf-8');
interview = {
interviewId: interviewId,
apiKey: OPENTOK_API_KEY,
source: source,
drafts: { participantId: source } // by participantId
};
ot.createSession(HOST, {}, function(sessionId) {
interview.sessionId = sessionId;
interviews[interviewId] = interview;
callback(interview, token);
});
};
exports.auth = function(req, res){
var key = process.env.OPENTOK_KEY,
secret = process.env.OPENTOK_SECRET,
opentok = new OpenTok.OpenTokSDK(key, secret);
// Check if we dont have an already made session.
if (auth !== null) {
res.json(auth);
return;
}
opentok.createSession(function(result) {
var session = result,
token = opentok.generateToken({
session_id: session,
// publisher role to give people permission to publish
role: OpenTok.RoleConstants.PUBLISHER
});
// save session info, and send it back.
auth = {
token: token,
sessionId: session,
key: key
};
res.json(auth);
});
};
function getSessionIdAndToken(request, response, callback){
if (request.query.room_id){
var sessionId = request.query.room_id;
var token = opentok.generateToken({session_id:sessionId, role:'publisher'});
callback(response, sessionId, token);
} else {
opentok.createSession('', function(result){
var sessionId = result;
var token = opentok.generateToken({session_id:sessionId, role:'publisher'});
callback(response, sessionId, token);
});
};
}
server = http.createServer(function(req, res){
var path = url.parse(req.url).pathname;
switch (path){
case '/':
res.writeHead(200, {'Content-Type': 'text/html'});
res.write(
renderExampleHTML(
OPENTOK_API_KEY,
globalSession.sessionId,
ot.generateToken()
)
);
res.end();
break;
case '/opentok-client.js':
fs.readFile(__dirname + path, function(err, data){
if (err) return send404(res);
res.writeHead(200, {'Content-Type': 'text/javascript'})
res.write(data, 'utf8');
res.end();
});
break;
default: send404(res);
}
}),
module.exports = function(config) {
var apiKey = config.apiKey,
ot = new opentok.OpenTokSDK(config.apiKey, config.apiSecret);
return {
index: function(req, res) {
ot.createSession('', {}, function(sessionId) {
res.redirect('/s/' + sessionId);
});
},
session: function(req, res) {
var p_apiKey = req.param("apiKey") || apiKey,
sessionId = req.params.sessionId,
token = req.param("token") ||
ot.generateToken({sessionId: sessionId,role: "publisher"});
res.render('index', {
apiKey: p_apiKey,
sessionId: sessionId,
token: token,
link: "http://" + req.headers.host + "/s/" + sessionId
});
}
};
};
var getToken = function (sessionid) {
console.log('creating token for session ' + sessionid);
var token = openTok.generateToken({
session_id: sessionid
});
console.log('token: ' + token);
return new ConnectionInfo(sessionid, token);
}
function tokresponse(sessionId, req, res){
// request for token per session, render stream
var token = OpenTokObject.generateToken({session_id: sessionId});
var data = {OpenTokKey:apikey, sessionId: sessionId, token:token};
// point to correct template based on teacher parameter
res.render('stream-' + ((req.params.teacher != undefined) ? req.params.teacher : 'student'), data);
}
ot.createSession('localhost', {}, function(session) {
tables[id].otSession = session["sessionId"];
users[id].otToken = ot.generateToken({
'connection_data': "userid_" + new Date().getTime(),
'role': "moderator"
});
socket.emit('session data', {session: tables[id].otSession, token: users[id].otToken});
socket.emit('table info', {});
});
function returnRoomResponse( res, data, json ){
data.apiKey = OTKEY;
data.token = OpenTokObject.generateToken( {session_id: data.sid, role:OpenTokLibrary.RoleConstants.MODERATOR} );
if( json == "" ){
res.json( data );
}else{
res.render( 'room', data );
}
}
app.get('/', function(req, res){
var _sessionId = ot.sessionId;
var _token = ot.generateToken({
'connection_data': "userid_" + new Date().getTime(),
'role': "publisher"
});
res.render('index', { title: 'Hot Potato', token: _token, sessionId: _sessionId, apikey: OPENTOK_API_KEY });
});
socket.on('candidate arrived', function(data) {
console.log('candidate connecting to table '+data.table);
sessionId = tables[data.table].otSession;
users[data.candidateId].otToken = ot.generateToken({
'connection_data': "userid_" + new Date().getTime(),
'role': "moderator"
});
socket.join(data.table);
socket.emit('session data', {session: sessionId, token: users[data.candidateId].otToken});
io.sockets.in(data.table).emit('candidate info', {id : data.candidateId});
});
app.get("/:room", function(req, res){
if(urlSessions[ req.params.room ] == undefined){
OpenTokObject.createSession(function(err, sessionId){
urlSessions[ req.params.room ] = sessionId;
sendResponse( sessionId, res );
});
}else{
sessionId = urlSessions[req.params.room];
sendResponse( sessionId, res );
}
});
app.get('/enter', function (req, res) {
console.log('entered' + req);
if (session === '') {
console.log('creating session');
openTok.createSession(location, function (result) {
session = result;
res.json(getToken(session));
});
} else {
res.json(getToken(session));
}
});
app.get('/archive/:archiveId', function (req, res) {
ot.getArchive(req.param('archiveId'), function (err, archive) {
if (err) {
res.send(404, err.message);
} else {
res.render('archive', {
name: archive.name,
url: archive.url
});
}
});
});
roomRef.once('value', function(dataSnapshot){
var sidSnapshot = dataSnapshot.child('sid');
var sid = sidSnapshot.val();
if(!sid){
OpenTokObject.createSession(function(sessionId){
sidSnapshot.ref().set( sessionId );
returnRoomResponse( res, { rid: rid, sid: sessionId }, path[1]);
});
}else{
returnRoomResponse( res, { rid: rid, sid: sid }, path[1]);
}
});
session: function(req, res) {
var p_apiKey = req.param("apiKey") || apiKey,
sessionId = req.params.sessionId,
token = req.param("token") ||
ot.generateToken({sessionId: sessionId,role: "publisher"});
res.render('index', {
apiKey: p_apiKey,
sessionId: sessionId,
token: token,
link: "http://" + req.headers.host + "/s/" + sessionId
});
}
app.get("/:room", function (req, res) {
var room = req.params.room;
room = room.toLowerCase();
if(urlSessions[ room ] === undefined){
OpenTokObject.createSession(function(sessionId){
urlSessions[ room ] = sessionId;
sendRoomResponse( sessionId, res, room, req.headers.host );
}, {'p2p.preference':'enabled'});
}else{
sessionId = urlSessions[room];
sendRoomResponse( sessionId, res, room, req.headers.host );
}
});
ot.createSession('localhost', {}, function(session) {
// Each user should be a moderator
var data = {
sessionId: session.sessionId,
token: ot.generateToken({
sessionId: session.sessionId,
role: opentok.Roles.MODERATOR
})
};
// Send initialization data back to the client
socket.emit('initial', data);
});
function playerConnectToLobby(lobbyId,playerId){
console.log("Player `"+playerId+"` attempting to connect to lobby `"+lobbyId+"`");
if(!gameData[lobbyId]){
console.log("LOBBY `"+lobbyId+"` DOESN'T EXIST!\n-");
return false;
}
var ldPublic=gameData[lobbyId][0];
var ldPrivate=gameData[lobbyId][1];
if(ldPrivate.numPlayers>=PLAYERSPERLOBBY){
console.log("Player `"+playerId+"` was denied entrance to lobby. (Reason: FULL)\n-");
return false;
}
if(ldPrivate.isPublic && ldPrivate.numPlayers==PLAYERSPERLOBBY-1){
delete publicLobbiesWithRoom[lobbyId];
delete publicGamesWithRoom[lobbyId];
}
var team0Len=ldPublic.players[0].length;
var team1Len=ldPublic.players[1].length;
playerTokens[playerId]=ot.generateToken({
'connection_data': playerId + new Date().getTime(),
'role': 'publisher'
});
var playerTemplate=
{
environment:{},
score:0,
team:team0Len<=team1Len?0:1,
playerId:playerId,
displayName:playerDisplayNames[playerId],
avatar:[0,0,0],
};
if(team0Len<=team1Len){
ldPublic.players[0].push(playerTemplate);
var t=0;
}else{
ldPublic.players[1].push(playerTemplate);
var t=1;
}
ldPrivate.numPlayers=team0Len+team1Len+1;
playerLobbyId[playerId]=lobbyId;
console.log("Player `"+playerId+"` connected to lobby. Team "+t+"\n-");
return playerTemplate;
}
function newLobby(isPublic){
var id=new Buffer(new Date().getTime()+"").toString('base64').slice(3,-2);
for(var i=1;gameData[id];i++) id=new Buffer(new Date().getTime()+i+"").toString('base64').slice(3,-2);
var pubVars=
{//PUBLIC VARIABLES:
environment:{},
ot_session: null,
test:1,
players:[
[],
[]
]
};
console.log(ot.createSession('localhost', {},function(pubVars){return function(session) {
pubVars.ot_session = session.sessionId;
}}(pubVars)));
var priVars=
{//PRIVATE VARIABLES:
inLobby:true,
isPublic:isPublic,
numPlayers:0,
gameName:""
};
gameData[id]=
[pubVars,
priVars,
{//FUNCTIONS:
pubVars:pubVars,
priVars:priVars,
lobbyId:id,
publish:function(){
//publishes data to players
var allPlayers=[].concat(this.pubVars.players[0],this.pubVars.players[1]);
for(var i=0;i<allPlayers.length;i++){
var playerSocket=playerSockets[allPlayers[i].playerId];
if(playerSocket) playerSocket.emit('publish',this.pubVars);
else console.log("ERROR BROKEN SOCKET - ERROR BROKEN SOCKET - ERROR BROKEN SOCKET - ERROR BROKEN SOCKET - ");
}
},
end:function(){
//ends current game
setTimeout(function(lId){return function(){switchToRandomGame(lId);}}(this.lobbyId),1); //This timeout is to prevent stack overflows for long games
}
}];
if(isPublic) publicLobbiesWithRoom[id]=true;
console.log("New "+(isPublic?"public":"private")+" lobby `"+id+"` created.\n-");
return id;
}
opentok.createSession(function(result) {
var session = result,
token = opentok.generateToken({
session_id: session,
// publisher role to give people permission to publish
role: OpenTok.RoleConstants.PUBLISHER
});
// save session info, and send it back.
auth = {
token: token,
sessionId: session,
key: key
};
res.json(auth);
});
function createSession(req, res) {
// avoid students to guess the url of the teacher
if(req.params.teacher && req.params.teacher != 'teacher') {
res.send(404);
}
// render stream pages
if (urlSessions[req.params.room] == undefined) {
OpenTokObject.createSession(function(sessionId){
urlSessions[req.params.room] = sessionId;
tokresponse(sessionId, req, res);
});
} else {
sessionId = urlSessions[req.params.room];
tokresponse(sessionId, req, res);
}
}
socket.get('id', function(err, id) {
users[id].type = 1;
tables[id] = {};
socket.join(id);
console.log('starting new table '+id);
console.log(tables[id]);
ot.createSession('localhost', {}, function(session) {
tables[id].otSession = session["sessionId"];
users[id].otToken = ot.generateToken({
'connection_data': "userid_" + new Date().getTime(),
'role': "moderator"
});
socket.emit('session data', {session: tables[id].otSession, token: users[id].otToken});
socket.emit('table info', {});
});
});
ot.createSession('localhost',{}, function(session) {
//Each user should be a moderator for their own session
var data = {
sessionId: session.sessionId,
token: ot.generateToken({
sessionId: session.sessionId,
role: opentok.Roles.MODERATOR
})
};
// Send initialization data back to the client
client.send({
event: 'initial',
data: data
});
});
ot.createSession(tokHost, {}, function(session) {
// Each user should be a moderator
var data = {
sessionId: session.sessionId,
token: ot.generateToken({
sessionId: session.sessionId,
role: opentok.Roles.MODERATOR
})
};
//socket.set('opentok', data);
// Send initialization data back to the client
socket.emit('message', {
event: 'initial',
data: data
});
});
// Sends the session info back to the client for the client to join
function enterSession(session, client) {
// Construct info object to pass back to client then send it
var opentok_info = {
sessionId: session.sessionId,
apiKey: OPENTOK_API_KEY,
token: ot.generateToken()
}
client.send(opentok_info);
// Create array to hold all the clients in the session
if (!session.clients) {
session.clients = new Array();
}
// Add the client to the session
session.clients.push(client.sessionId);
session_map[client.sessionId] = session; // Use map later to identify what session client was in
}
app.get("/:rid", function( req, res ){
// make sure that we are always in https
console.log( req.url );
if(req.header('x-forwarded-proto')!="https" && process.env.NODE_ENV == "production" ){
res.redirect( 'https://opentokrtc.com'+req.url );
return;
}
// find request format, json or html?
var path = req.params.rid.split(".json");
var rid = path[0];
// Generate sessionId if there are no existing session Id's
if( !rooms[rid] ){
OpenTokObject.createSession(function(sessionId){
rooms[rid] = sessionId;
returnRoomResponse( res, { rid: rid, sid: sessionId }, path[1]);
});
}else{
returnRoomResponse( res, { rid: rid, sid: rooms[rid] }, path[1]);
}
});
ot_sessions = new Array(); // Array for holding all sessions we have generated
// Finds an available session for the client to connect to
function getSession(client) {
var session;
// Look through all sessions to find a session that has less than the max number of sessions
// NOTE: We start searching from the top of the array since it is more likely a non-full session is there
for (var i = ot_sessions.length - 1; i >= 0; i--) {
var tmp_session = ot_sessions[i];
if (tmp_session.clients.length < MAX_SESSION_CONNECTIONS) {
session = tmp_session;
break;
}
}
if (!session) {
// If we didn't find a session, generate one and enter it
ot.createSession('localhost',{},function(session) {
ot_sessions.push(session);
enterSession(session,client);
})
} else {
// Otherwise enter the session we found
enterSession(session, client);
}
}
myRootRef.once( "value", function( snapshot ){
var info = snapshot.val();
if( !info ){
res.redirect('/');
return
}
console.log( info );
if( info.sid && info.sid.length > 3 ){
console.log( "session id generated" );
console.log( info.sid );
returnRoomResponse( res, { rid: rid, sid: info.sid }, path[1]);
}else{
console.log(" no session id found ");
OpenTokObject.createSession(function(sessionId){
console.log( "sessionId generated" );
console.log( sessionId );
myRootRef.child( "sid" ).set( sessionId, function(){
console.log( "set session id" );
console.log( sessionId );
returnRoomResponse( res, { rid: rid, sid: sessionId }, path[1]);
});
});
}
});
socket.get('socket_id', function(err, socket_id) {
sid = socket_id;
// Create a "user" data object for me
var me = {
sessionId: message.data.sessionId,
clientId: sid
};
console.log("----------------------------------> meeee <------------------------------");
console.log();
console.log(me);
tmp_socket = manager.sockets[sid];
var partner;
var partnerClient;
// Look for a user to partner with in the list of solo users
for (var i = 0; i < soloUsers.length; i++) {
var tmpUser = soloUsers[i];
// Make sure our last partner is not our new partner
if (tmp_socket.partner != tmpUser && tmp_socket != tmpUser) {
// Get the socket client for this user
//let's try this approach if clientId has auth id for socket we should be very good!
// In that case we have partnerClient= Socket do parceiro! Um simples partner.emit(message, subscribe) makes us happy
partnerClient = manager.sockets[tmpUser.clientId];
// Remove the partner we found from the list of solo users
soloUsers.splice(i, 1);
// If the user we found exists...
if (partnerClient) {
// Set as our partner and quit the loop today
partner = tmpUser;
break;
}
}
else{
//isto nao devia acontecer na primeira iteração
console.log("failllllllllllllllllllllll");
}
}
// If we found a partner...
if (partner) {
//socket.emit('debug')
// Tell myself to subscribe to my partner
socket.emit('message', {
event: 'subscribe',
data: {
sessionId: partner.sessionId,
token: ot.generateToken({
sessionId: partner.sessionId,
role: opentok.Roles.SUBSCRIBER
})
}
});
// Tell my partner to subscribe to me
partnerClient.emit('message', {
event: 'subscribe',
data: {
sessionId: me.sessionId,
token: ot.generateToken({
sessionId: me.sessionId,
role: opentok.Roles.SUBSCRIBER
})
}
});
// Mark that my new partner and me are partners
tmp_socket.partner = partner;
partnerClient.partner = me;
// Mark that we are not in the list of solo users anymore
socket.inList = false;
partnerClient.inList = false;
//assign a room to be used to chat on
//room id = both socket ids plus a random number from 0 to 10000
var roomId = partner.sessionId + me.sessionId + "|" + Math.floor((Math.random()*10000)+1);
socket.join(roomId);
partnerClient.join(roomId);
console.log("Generated room ID:"+roomId);
//TODO objectify these methodsm very unclean code here
socket.set('chatRoomId', roomId, function(){
socket.emit('message', {
event: 'chatStatus',
data: {
status: 'online'
}
})
});
partnerClient.set('chatRoomId', roomId, function(){
partnerClient.emit('message', {
event: 'chatStatus',
data: {
status: 'online'
}
})
});
}
else {
// Delete that I had a partner if I had one
if (tmp_socket.partner) {
delete tmp_socket.partner;
}
// Add myself to list of solo users if I'm not in the list
if (!socket.inList) {
socket.inList = true;
soloUsers.push(me);
}
// Tell myself that there is nobody to chat with right now
socket.emit('message', {
event: 'empty'
});
//TODO put this code in a method..
//make you leave the room for chatting if you were in one
socket.get('chatRoomId', function(err, chatRoomId)
{
socket.emit('message', {
event: 'chatStatus',
data: {
status:'offline'
}
});
if (err)
{
//TODO ?
console.log('Error getting chatRoomId. ' + err);
return;
}
socket.leave(chatRoomId);
socket.del('chatRoomId');
});
}
});