570 lines
22 KiB
JavaScript
570 lines
22 KiB
JavaScript
/**
|
|
* Publish usernames to all the sockets
|
|
* @param {string} meetingID ID of the meeting
|
|
* @param {string} sessionID ID of the user
|
|
* @param {Function} callback callback to call when finished
|
|
* @return {undefined} publish to Redis PubSub
|
|
*/
|
|
exports.publishUsernames = function(meetingID, sessionID, callback) {
|
|
var usernames = [];
|
|
redisAction.getUsers(meetingID, function (users) {
|
|
for (var i = users.length - 1; i >= 0; i--){
|
|
usernames.push({ 'name' : users[i].username, 'id' : users[i].pubID });
|
|
};
|
|
var receivers = sessionID != undefined ? sessionID : meetingID;
|
|
pub.publish(receivers, JSON.stringify(['user list change', usernames]));
|
|
if(callback) callback(true);
|
|
});
|
|
store.scard(redisAction.getUsersString(meetingID), function(err, cardinality) {
|
|
if(cardinality == '0') {
|
|
redisAction.processMeeting(meetingID);
|
|
if(callback) callback(false);
|
|
}
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Publish presenter to appropriate clients.
|
|
* @param {string} meetingID ID of the meeting
|
|
* @param {string} sessionID ID of the user
|
|
* @param {Function} callback callback to call when finished
|
|
* @return {undefined} publish to Redis PubSub
|
|
*/
|
|
exports.publishPresenter = function(meetingID, sessionID, callback) {
|
|
redisAction.getPresenterPublicID(meetingID, function(publicID) {
|
|
var receivers = sessionID != undefined ? sessionID : meetingID;
|
|
pub.publish(receivers, JSON.stringify(['setPresenter', publicID]));
|
|
if(callback) callback(true);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Get all messages from Redis and publish to a specific sessionID (user)
|
|
* @param {string} meetingID ID of the meeting
|
|
* @param {string} sessionID ID of the user
|
|
* @param {Function} callback callback to call when finished
|
|
* @return {undefined} publish to Redis PubSub
|
|
*/
|
|
exports.publishMessages = function(meetingID, sessionID, callback) {
|
|
var messages = [];
|
|
redisAction.getCurrentPresentationID(meetingID, function(presentationID) {
|
|
redisAction.getCurrentPageID(meetingID, presentationID, function(pageID) {
|
|
redisAction.getItems(meetingID, presentationID, pageID, 'messages', function (messages) {
|
|
var receivers = sessionID != undefined ? sessionID : meetingID;
|
|
pub.publish(receivers, JSON.stringify(['all_messages', messages]));
|
|
if(callback) callback();
|
|
});
|
|
});
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Publish list of slides from Redis to the appropriate clients
|
|
* @param {string} meetingID ID of the meeting
|
|
* @param {string} sessionID ID of the user
|
|
* @param {Function} callback callback to call when finished
|
|
* @return {undefined} publish to Redis PubSub
|
|
*/
|
|
exports.publishSlides = function(meetingID, sessionID, callback) {
|
|
var slides = [];
|
|
redisAction.getCurrentPresentationID(meetingID, function(presentationID) {
|
|
redisAction.getPageIDs(meetingID, presentationID, function(presentationID, pageIDs) {
|
|
var numOfSlides = pageIDs.length;
|
|
var slideCount = 0;
|
|
for(var i = 0; i < numOfSlides; i++) {
|
|
redisAction.getPageImage(meetingID, presentationID, pageIDs[i], function(pageID, filename) {
|
|
redisAction.getImageSize(meetingID, presentationID, pageID, function(width, height) {
|
|
slides.push(['images/presentation' +presentationID+'/'+filename, width, height]);
|
|
if(slides.length == numOfSlides) {
|
|
var receivers = sessionID != undefined ? sessionID : meetingID;
|
|
pub.publish(receivers, JSON.stringify(['all_slides', slides]));
|
|
if(callback) callback();
|
|
}
|
|
});
|
|
});
|
|
}
|
|
});
|
|
});
|
|
};
|
|
/**
|
|
* Publish list of shapes from Redis to appropriate clients
|
|
* @param {string} meetingID ID of the meeting
|
|
* @param {string} sessionID ID of the user
|
|
* @param {Function} callback callback to call when finished
|
|
* @return {undefined} publish to Redis PubSub
|
|
*/
|
|
exports.publishShapes = function(meetingID, sessionID, callback) {
|
|
var shapes = [];
|
|
redisAction.getCurrentPresentationID(meetingID, function(presentationID) {
|
|
redisAction.getCurrentPageID(meetingID, presentationID, function(pageID) {
|
|
redisAction.getItems(meetingID, presentationID, pageID, 'currentshapes', function (shapes) {
|
|
var receivers = sessionID != undefined ? sessionID : meetingID;
|
|
pub.publish(receivers, JSON.stringify(['all_shapes', shapes]));
|
|
if(callback) callback();
|
|
});
|
|
});
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Publish viewbox from Redis to appropriate clients
|
|
* @param {string} meetingID ID of the meeting
|
|
* @param {string} sessionID ID of the user
|
|
* @param {Function} callback callback to call when finished
|
|
* @return {undefined} publish to Redis PubSub
|
|
*/
|
|
exports.publishViewBox = function(meetingID, sessionID, callback) {
|
|
redisAction.getCurrentPresentationID(meetingID, function(presentationID) {
|
|
redisAction.getViewBox(meetingID, function(viewBox) {
|
|
viewBox = JSON.parse(viewBox);
|
|
var receivers = sessionID != undefined ? sessionID : meetingID;
|
|
pub.publish(receivers, JSON.stringify(['paper', viewBox[0], viewBox[1], viewBox[2], viewBox[3]]));
|
|
if(callback) callback();
|
|
});
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Publish tool from Redis to appropriate clients
|
|
* @param {string} meetingID ID of the meeting
|
|
* @param {string} sessionID ID of the user
|
|
* @param {string} tool [description]
|
|
* @param {Function} callback callback to call when finished
|
|
* @return {undefined} publish to Redis PubSub
|
|
*/
|
|
exports.publishTool = function(meetingID, sessionID, tool, callback) {
|
|
redisAction.getCurrentTool(meetingID, function(tool) {
|
|
var receivers = sessionID != undefined ? sessionID : meetingID;
|
|
pub.publish(receivers, JSON.stringify(['toolChanged', tool]));
|
|
if(callback) callback();
|
|
});
|
|
};
|
|
|
|
/**
|
|
* All socket IO events that can be emitted by the client
|
|
* @param {[type]} socket [description]
|
|
*/
|
|
exports.SocketOnConnection = function(socket) {
|
|
|
|
//When a user sends a message...
|
|
socket.on('msg', function (msg) {
|
|
msg = sanitizer.escape(msg);
|
|
var handshake = socket.handshake;
|
|
var sessionID = handshake.sessionID;
|
|
var meetingID = handshake.meetingID;
|
|
redisAction.isValidSession(meetingID, sessionID, function (reply) {
|
|
if(reply) {
|
|
if(msg.length > max_chat_length) {
|
|
pub.publish(sessionID, JSON.stringify(['msg', 'System', 'Message too long.']));
|
|
}
|
|
else {
|
|
var username = handshake.username;
|
|
pub.publish(meetingID, JSON.stringify(['msg', username, msg]));
|
|
var messageID = rack(); //get a randomly generated id for the message
|
|
|
|
//try later taking these nulls out and see if the function still works
|
|
store.rpush(redisAction.getMessagesString(meetingID, null, null), messageID); //store the messageID in the list of messages
|
|
store.hmset(redisAction.getMessageString(meetingID, null, null, messageID), 'message', msg, 'username', username);
|
|
}
|
|
}
|
|
});
|
|
});
|
|
|
|
/**
|
|
* When a user connects to the socket...
|
|
* @return {undefined} publish to Redis PubSub
|
|
*/
|
|
socket.on('user connect', function () {
|
|
var handshake = socket.handshake;
|
|
var sessionID = handshake.sessionID;
|
|
var meetingID = handshake.meetingID;
|
|
redisAction.isValidSession(meetingID, sessionID, function (reply) {
|
|
if(reply) {
|
|
var username = handshake.username;
|
|
var socketID = socket.id;
|
|
|
|
socket.join(meetingID); //join the socket Room with value of the meetingID
|
|
socket.join(sessionID); //join the socket Room with value of the sessionID
|
|
|
|
//add socket to list of sockets.
|
|
redisAction.getUserProperties(meetingID, sessionID, function(properties) {
|
|
var numOfSockets = parseInt(properties.sockets, 10);
|
|
numOfSockets+=1;
|
|
store.hset(redisAction.getUserString(meetingID, sessionID), 'sockets', numOfSockets);
|
|
if ((properties.refreshing == 'false') && (properties.dupSess == 'false')) {
|
|
//all of the next sessions created with this sessionID are duplicates
|
|
store.hset(redisAction.getUserString(meetingID, sessionID), 'dupSess', true);
|
|
socketAction.publishUsernames(meetingID, null, function() {
|
|
socketAction.publishPresenter(meetingID);
|
|
});
|
|
}
|
|
else {
|
|
store.hset(redisAction.getUserString(meetingID, sessionID), 'refreshing', false);
|
|
socketAction.publishUsernames(meetingID, sessionID, function() {
|
|
socketAction.publishPresenter(meetingID, sessionID);
|
|
});
|
|
}
|
|
socketAction.publishMessages(meetingID, sessionID);
|
|
socketAction.publishSlides(meetingID, sessionID, function() {
|
|
socketAction.publishTool(meetingID, sessionID);
|
|
socketAction.publishShapes(meetingID, sessionID);
|
|
socketAction.publishViewBox(meetingID, sessionID);
|
|
});
|
|
});
|
|
}
|
|
});
|
|
});
|
|
|
|
/**
|
|
* When a user disconnects from the socket...
|
|
* @return {undefined} publish to Redis PubSub
|
|
*/
|
|
socket.on('disconnect', function () {
|
|
var handshake = socket.handshake;
|
|
var sessionID = handshake.sessionID;
|
|
var meetingID = handshake.meetingID;
|
|
//check if user is still in database
|
|
redisAction.isValidSession(meetingID, sessionID, function (isValid) {
|
|
if(isValid) {
|
|
var username = handshake.username;
|
|
var socketID = socket.id;
|
|
redisAction.updateUserProperties(meetingID, sessionID, ['refreshing', true], function(success) {
|
|
setTimeout(function () {
|
|
//in one second, check again...
|
|
redisAction.isValidSession(meetingID, sessionID, function (isValid) {
|
|
if(isValid) {
|
|
redisAction.getUserProperties(meetingID, sessionID, function(properties) {
|
|
var numOfSockets = parseInt(properties.sockets, 10);
|
|
numOfSockets-=1;
|
|
if(numOfSockets == 0) {
|
|
redisAction.deleteUser(meetingID, sessionID, function() {
|
|
socketAction.publishUsernames(meetingID);
|
|
});
|
|
}
|
|
else {
|
|
redisAction.updateUserProperties(meetingID, sessionID, ['sockets', numOfSockets]);
|
|
}
|
|
});
|
|
}
|
|
else {
|
|
socketAction.publishUsernames(meetingID);
|
|
socketAction.publishPresenter(meetingID, sessionID);
|
|
}
|
|
});
|
|
}, 1000);
|
|
});
|
|
}
|
|
});
|
|
});
|
|
|
|
/**
|
|
* When the user logs out
|
|
* @return {undefined} publish to Redis PubSub
|
|
*/
|
|
socket.on('logout', function() {
|
|
var handshake = socket.handshake;
|
|
var sessionID = handshake.sessionID;
|
|
var meetingID = handshake.meetingID;
|
|
redisAction.isValidSession(meetingID, sessionID, function (isValid) {
|
|
if(isValid) {
|
|
//initialize local variables
|
|
var username = handshake.username;
|
|
//remove the user from the list of users
|
|
store.srem(redisAction.getUsersString(meetingID), sessionID, function(numDeleted) {
|
|
//delete key from database
|
|
store.del(redisAction.getUserString(meetingID, sessionID), function(reply) {
|
|
pub.publish(sessionID, JSON.stringify(['logout'])); //send to all users on same session (all tabs)
|
|
socket.disconnect(); //disconnect own socket
|
|
});
|
|
});
|
|
}
|
|
socketAction.publishUsernames(meetingID);
|
|
});
|
|
});
|
|
|
|
/**
|
|
* A user clicks to change to previous slide
|
|
* @return {undefined} publish to Redis PubSub
|
|
*/
|
|
socket.on('prevslide', function () {
|
|
var handshake = socket.handshake;
|
|
var sessionID = handshake.sessionID;
|
|
var meetingID = handshake.meetingID;
|
|
redisAction.getPresenterSessionID(meetingID, function(presenterID) {
|
|
if(presenterID == sessionID) {
|
|
redisAction.getCurrentPresentationID(meetingID, function(presentationID) {
|
|
redisAction.changeToPrevPage(meetingID, presentationID, function(pageID){
|
|
redisAction.getPageImage(meetingID, presentationID, pageID, function(pageID, filename) {
|
|
pub.publish(meetingID, JSON.stringify(['changeslide', 'images/presentation' + presentationID + '/'+filename]));
|
|
pub.publish(meetingID, JSON.stringify(['clrPaper']));
|
|
socketAction.publishShapes(meetingID);
|
|
});
|
|
});
|
|
});
|
|
}
|
|
});
|
|
});
|
|
|
|
/**
|
|
* A user clicks to change to next slide
|
|
* @return {undefined} publish to Redis PubSub
|
|
*/
|
|
socket.on('nextslide', function () {
|
|
var handshake = socket.handshake;
|
|
var sessionID = handshake.sessionID;
|
|
var meetingID = handshake.meetingID;
|
|
redisAction.getPresenterSessionID(meetingID, function(presenterID) {
|
|
if(presenterID == sessionID) {
|
|
redisAction.getCurrentPresentationID(meetingID, function(presentationID) {
|
|
redisAction.changeToNextPage(meetingID, presentationID, function(pageID){
|
|
redisAction.getPageImage(meetingID, presentationID, pageID, function(pageID, filename) {
|
|
pub.publish(meetingID, JSON.stringify(['changeslide', 'images/presentation' + presentationID + '/'+filename]));
|
|
pub.publish(meetingID, JSON.stringify(['clrPaper']));
|
|
socketAction.publishShapes(meetingID);
|
|
});
|
|
});
|
|
});
|
|
}
|
|
});
|
|
});
|
|
|
|
/**
|
|
* When a rectangle creation event is received
|
|
* @param {string} shape type of shape
|
|
* @param {Object} data information needed to draw the shape
|
|
* @return {undefined} publish to Redis PubSub
|
|
*/
|
|
socket.on('makeShape', function (shape, data) {
|
|
var meetingID = socket.handshake.meetingID;
|
|
redisAction.getPresenterSessionID(meetingID, function(presenterID) {
|
|
if(presenterID == socket.handshake.sessionID) {
|
|
pub.publish(meetingID, JSON.stringify(['makeShape', shape, data]));
|
|
}
|
|
});
|
|
});
|
|
|
|
/**
|
|
* When a update shape event is received
|
|
* @param {string} shape type of shape
|
|
* @param {Object} data information needed to draw the shape
|
|
* @return {undefined} publish to Redis PubSub
|
|
*/
|
|
socket.on('updShape', function (shape, data) {
|
|
var meetingID = socket.handshake.meetingID;
|
|
redisAction.getPresenterSessionID(meetingID, function(presenterID) {
|
|
if(presenterID == socket.handshake.sessionID) {
|
|
pub.publish(meetingID, JSON.stringify(['updShape', shape, data]));
|
|
}
|
|
});
|
|
});
|
|
|
|
/**
|
|
* When a cursor move event is received
|
|
* @param {[type]} x x coord of cursor as a percentage of width
|
|
* @param {[type]} y y coord of cursor as a percentage of height
|
|
* @return {undefined} publish to Redis PubSub
|
|
*/
|
|
socket.on('mvCur', function (x, y) {
|
|
var meetingID = socket.handshake.meetingID;
|
|
redisAction.getPresenterSessionID(meetingID, function(presenterID) {
|
|
if(presenterID == socket.handshake.sessionID) {
|
|
pub.publish(meetingID, JSON.stringify(['mvCur', x, y]));
|
|
}
|
|
});
|
|
});
|
|
|
|
/**
|
|
* When a clear Paper event is received
|
|
* @return {undefined} publish to Redis PubSub
|
|
*/
|
|
socket.on('clrPaper', function () {
|
|
var meetingID = socket.handshake.meetingID;
|
|
var sessionID = socket.handshake.sessionID;
|
|
redisAction.getPresenterSessionID(meetingID, function(presenterID) {
|
|
if(presenterID == socket.handshake.sessionID) {
|
|
redisAction.getCurrentPresentationID(meetingID, function(presentationID) {
|
|
redisAction.getCurrentPageID(meetingID, presentationID, function(pageID) {
|
|
redisAction.getItemIDs(meetingID, presentationID, pageID, 'currentshapes', function(meetingID, presentationID, pageID, itemIDs, itemName) {
|
|
redisAction.deleteItemList(meetingID, presentationID, pageID, itemName, itemIDs);
|
|
});
|
|
pub.publish(meetingID, JSON.stringify(['clrPaper']));
|
|
socketAction.publishTool(meetingID, sessionID);
|
|
});
|
|
});
|
|
}
|
|
});
|
|
});
|
|
|
|
/**
|
|
* When the user wishes to set the presenter to another user
|
|
* @param {[type]} publicID public ID of user to make presenter
|
|
* @return {undefined} publish to Redis PubSub
|
|
*/
|
|
socket.on('setPresenter', function (publicID) {
|
|
console.log('setting presenter to' + publicID);
|
|
var meetingID = socket.handshake.meetingID;
|
|
redisAction.setPresenterFromPublicID(meetingID, publicID, function(success) {
|
|
if(success) {
|
|
pub.publish(meetingID, JSON.stringify(['setPresenter', publicID]));
|
|
}
|
|
});
|
|
});
|
|
|
|
/**
|
|
* When a user is updating the viewBox of the paper
|
|
* @param {number} cx x-offset from corner as a percentage of width
|
|
* @param {number} cy y-offset from corner as a percentage of height
|
|
* @param {number} sw width of page as a percentage of original width
|
|
* @param {number} sh height of page as a percentage of original height
|
|
* @return {undefined} publish to Redis PubSub
|
|
*/
|
|
socket.on('paper', function (cx, cy, sw, sh) {
|
|
var meetingID = socket.handshake.meetingID;
|
|
redisAction.getPresenterSessionID(meetingID, function(presenterID) {
|
|
if(presenterID == socket.handshake.sessionID) {
|
|
pub.publish(socket.handshake.meetingID, JSON.stringify(['paper', cx, cy, sw, sh]));
|
|
if(!sw && !sh) {
|
|
redisAction.getViewBox(socket.handshake.meetingID, function(viewbox) {
|
|
var viewbox = JSON.parse(viewbox);
|
|
redisAction.setViewBox(socket.handshake.meetingID, JSON.stringify([cx, cy, viewbox[2], viewbox[3]]));
|
|
});
|
|
}
|
|
else redisAction.setViewBox(socket.handshake.meetingID, JSON.stringify([cx, cy, sw, sh]));
|
|
}
|
|
});
|
|
});
|
|
|
|
/**
|
|
* When a user is zooming
|
|
* @param {number} delta amount the mouse scroll has moved
|
|
* @return {undefined} publish to Redis PubSub
|
|
*/
|
|
socket.on('zoom', function(delta) {
|
|
var meetingID = socket.handshake.meetingID;
|
|
redisAction.getPresenterSessionID(meetingID, function(presenterID) {
|
|
if(presenterID == socket.handshake.sessionID) {
|
|
pub.publish(meetingID, JSON.stringify(['zoom', delta]));
|
|
}
|
|
});
|
|
});
|
|
|
|
/**
|
|
* When a user finishes panning
|
|
* @return {undefined} publish to Redis PubSub
|
|
*/
|
|
socket.on('panStop', function() {
|
|
var meetingID = socket.handshake.meetingID;
|
|
redisAction.getPresenterSessionID(meetingID, function(presenterID) {
|
|
if(presenterID == socket.handshake.sessionID) {
|
|
pub.publish(meetingID, JSON.stringify(['panStop']));
|
|
}
|
|
});
|
|
});
|
|
|
|
/**
|
|
* Undoing the last shape
|
|
* @return {undefined} publish to Redis PubSub
|
|
*/
|
|
socket.on('undo', function() {
|
|
var meetingID = socket.handshake.meetingID;
|
|
redisAction.getPresenterSessionID(meetingID, function(presenterID) {
|
|
if(presenterID == socket.handshake.sessionID) {
|
|
redisAction.getCurrentPresentationID(meetingID, function(presentationID) {
|
|
redisAction.getCurrentPageID(meetingID, presentationID, function(pageID) {
|
|
//pop the last shape off the current list of shapes
|
|
store.rpop(redisAction.getCurrentShapesString(meetingID, presentationID, pageID), function(err, reply) {
|
|
socketAction.publishShapes(meetingID);
|
|
});
|
|
});
|
|
});
|
|
}
|
|
});
|
|
});
|
|
|
|
/**
|
|
* Telling everyone the current text has been finished
|
|
* @return {undefined} publish to Redis PubSub
|
|
*/
|
|
socket.on('textDone', function() {
|
|
var meetingID = socket.handshake.meetingID;
|
|
redisAction.getPresenterSessionID(meetingID, function(presenterID) {
|
|
if(presenterID == socket.handshake.sessionID) {
|
|
pub.publish(meetingID, JSON.stringify(['textDone']));
|
|
}
|
|
});
|
|
});
|
|
|
|
/**
|
|
* Saving a shape to Redis. Does not provide feedback to client(s)
|
|
* @param {string} shape type of shape
|
|
* @param {Object} data information needed to recreate shape
|
|
* @return {undefined} publish to Redis PubSub
|
|
*/
|
|
socket.on('saveShape', function (shape, data) {
|
|
var handshake = socket.handshake;
|
|
var meetingID = handshake.meetingID;
|
|
redisAction.getPresenterSessionID(meetingID, function(presenterID) {
|
|
if(presenterID == handshake.sessionID) {
|
|
redisAction.getCurrentPresentationID(meetingID, function(presentationID) {
|
|
redisAction.getCurrentPageID(meetingID, presentationID, function(pageID) {
|
|
var shapeID = rack(); //get a randomly generated id for the shape
|
|
store.rpush(redisAction.getCurrentShapesString(meetingID, presentationID, pageID), shapeID);
|
|
store.hmset(redisAction.getShapeString(meetingID, presentationID, pageID, shapeID),
|
|
'shape', shape, 'data', data, function(err, reply) {
|
|
});
|
|
});
|
|
});
|
|
}
|
|
});
|
|
});
|
|
|
|
/**
|
|
* Changing the currently set tool.
|
|
* Set the current tool in Redis, then publish
|
|
* the tool change to the members
|
|
* @param {string} tool name of the tool to change to
|
|
* @return {undefined} publish to Redis PubSub
|
|
*/
|
|
socket.on('changeTool', function (tool) {
|
|
var handshake = socket.handshake;
|
|
var meetingID = handshake.meetingID;
|
|
redisAction.getPresenterSessionID(meetingID, function(presenterID) {
|
|
if(presenterID == socket.handshake.sessionID) {
|
|
redisAction.setCurrentTool(meetingID, tool, function(success) {
|
|
if(success) {
|
|
pub.publish(meetingID, JSON.stringify(['toolChanged', tool]));
|
|
}
|
|
});
|
|
}
|
|
});
|
|
});
|
|
|
|
/**
|
|
* If a user requests all the shapes,
|
|
* publish the shapes to everyone.
|
|
* Only reason this happens is when its fit changes.
|
|
* @return {undefined} publish to Redis PubSub
|
|
*/
|
|
socket.on('all_shapes', function(){
|
|
var handshake = socket.handshake;
|
|
var meetingID = handshake.meetingID;
|
|
var sessionID = handshake.sessionID;
|
|
socketAction.publishShapes(meetingID);
|
|
});
|
|
|
|
/**
|
|
* Updating the fit of the image to the whiteboard
|
|
* @param {boolean} fit true for fit to page and false for fit to width
|
|
* @return {undefined} publish to Redis PubSub
|
|
*/
|
|
socket.on('fitToPage', function(fit) {
|
|
var handshake = socket.handshake;
|
|
var meetingID = handshake.meetingID;
|
|
redisAction.getPresenterSessionID(meetingID, function(presenterID) {
|
|
if(presenterID == sockt.handshake.sessionID) {
|
|
pub.publish(meetingID, JSON.stringify(['fitToPage', fit]));
|
|
}
|
|
});
|
|
});
|
|
};
|