HackMD/lib/realtime.js

802 lines
27 KiB
JavaScript
Raw Normal View History

2015-05-04 07:53:29 +00:00
//realtime
//external modules
var cookie = require('cookie');
var cookieParser = require('cookie-parser');
var url = require('url');
var async = require('async');
var LZString = require('lz-string');
var shortId = require('shortid');
var randomcolor = require("randomcolor");
2015-06-01 10:04:25 +00:00
var Chance = require('chance'),
chance = new Chance();
2015-07-01 16:10:20 +00:00
var moment = require('moment');
2015-05-04 07:53:29 +00:00
//core
var config = require("../config.js");
2015-07-01 16:10:20 +00:00
var logger = require("./logger.js");
2015-05-04 07:53:29 +00:00
//ot
var ot = require("./ot/index.js");
2015-05-04 07:53:29 +00:00
//others
var db = require("./db.js");
var Note = require("./note.js");
var User = require("./user.js");
//public
var realtime = {
io: null,
2015-06-01 10:04:25 +00:00
onAuthorizeSuccess: onAuthorizeSuccess,
onAuthorizeFail: onAuthorizeFail,
2015-05-04 07:53:29 +00:00
secure: secure,
connection: connection,
getStatus: getStatus
};
2015-06-01 10:04:25 +00:00
function onAuthorizeSuccess(data, accept) {
accept();
2015-06-01 10:04:25 +00:00
}
function onAuthorizeFail(data, message, error, accept) {
accept(); //accept whether authorize or not to allow anonymous usage
2015-06-01 10:04:25 +00:00
}
//secure the origin by the cookie
2015-05-04 07:53:29 +00:00
function secure(socket, next) {
try {
var handshakeData = socket.request;
if (handshakeData.headers.cookie) {
handshakeData.cookie = cookie.parse(handshakeData.headers.cookie);
handshakeData.sessionID = cookieParser.signedCookie(handshakeData.cookie[config.sessionname], config.sessionsecret);
if (handshakeData.sessionID &&
handshakeData.cookie[config.sessionname] &&
handshakeData.cookie[config.sessionname] != handshakeData.sessionID) {
if (config.debug)
logger.info("AUTH success cookie: " + handshakeData.sessionID);
return next();
} else {
2015-05-04 07:53:29 +00:00
next(new Error('AUTH failed: Cookie is invalid.'));
}
} else {
next(new Error('AUTH failed: No cookie transmitted.'));
}
} catch (ex) {
next(new Error("AUTH failed:" + JSON.stringify(ex)));
}
}
function emitCheck(note) {
var out = {
updatetime: note.updatetime,
lastchangeuser: note.lastchangeuser,
lastchangeuserprofile: note.lastchangeuserprofile
};
realtime.io.to(note.id).emit('check', out);
/*
for (var i = 0, l = note.socks.length; i < l; i++) {
var sock = note.socks[i];
sock.emit('check', out);
};
*/
}
2015-05-04 07:53:29 +00:00
//actions
var users = {};
var notes = {};
//update when the note is dirty
2015-05-04 07:53:29 +00:00
var updater = setInterval(function () {
async.each(Object.keys(notes), function (key, callback) {
var note = notes[key];
if (note.server.isDirty) {
2015-05-04 07:53:29 +00:00
if (config.debug)
2015-07-01 16:10:20 +00:00
logger.info("updater found dirty note: " + key);
updaterUpdateMongo(note, function(err, result) {
if (err) return callback(err, null);
updaterUpdatePostgres(note, function(err, result) {
if (err) return callback(err, null);
callback(null, null);
});
});
} else {
callback(null, null);
2015-05-04 07:53:29 +00:00
}
}, function (err) {
2015-07-01 16:10:20 +00:00
if (err) return logger.error('updater error', err);
2015-05-04 07:53:29 +00:00
});
}, 1000);
function updaterUpdateMongo(note, callback) {
Note.findNote(note.id, function (err, _note) {
if (err || !_note) return callback(err, null);
if (note.lastchangeuser) {
if (_note.lastchangeuser != note.lastchangeuser) {
var lastchangeuser = note.lastchangeuser;
var lastchangeuserprofile = null;
User.findUser(lastchangeuser, function (err, user) {
if (err) return callback(err, null);
if (user && user.profile) {
var profile = JSON.parse(user.profile);
if (profile) {
lastchangeuserprofile = {
name: profile.displayName || profile.username,
photo: User.parsePhotoByProfile(profile)
}
_note.lastchangeuser = lastchangeuser;
note.lastchangeuserprofile = lastchangeuserprofile;
Note.updateLastChangeUser(_note, lastchangeuser, function (err, result) {
if (err) return callback(err, null);
callback(null, null);
});
}
}
});
}
} else {
_note.lastchangeuser = null;
note.lastchangeuserprofile = null;
Note.updateLastChangeUser(_note, null, function (err, result) {
if (err) return callback(err, null);
callback(null, null);
});
}
});
}
function updaterUpdatePostgres(note, callback) {
//postgres update
var body = note.server.document;
var title = Note.getNoteTitle(body);
title = LZString.compressToBase64(title);
body = LZString.compressToBase64(body);
db.saveToDB(note.id, title, body, function (err, result) {
if (err) return callback(err, null);
note.server.isDirty = false;
note.updatetime = Date.now();
emitCheck(note);
callback(null, null);
});
}
//clean when user not in any rooms or user not in connected list
var cleaner = setInterval(function () {
async.each(Object.keys(users), function (key, callback) {
var socket = realtime.io.sockets.connected[key];
if ((!socket && users[key]) ||
(socket && (!socket.rooms || socket.rooms.length <= 0))) {
if (config.debug)
logger.info("cleaner found redundant user: " + key);
if (!socket) {
socket = {
id: key
};
}
disconnectSocketQueue.push(socket);
disconnect(socket);
}
callback(null, null);
}, function (err) {
if (err) return logger.error('cleaner error', err);
});
}, 60000);
2015-05-04 07:53:29 +00:00
function getStatus(callback) {
db.countFromDB(function (err, data) {
2015-07-01 16:10:20 +00:00
if (err) return logger.info(err);
2015-05-04 07:53:29 +00:00
var distinctaddresses = [];
2015-07-01 16:10:20 +00:00
var regaddresses = [];
var distinctregaddresses = [];
2015-05-04 07:53:29 +00:00
Object.keys(users).forEach(function (key) {
2015-07-01 16:10:20 +00:00
var user = users[key];
2015-05-04 07:53:29 +00:00
var found = false;
for (var i = 0; i < distinctaddresses.length; i++) {
2015-07-01 16:10:20 +00:00
if (user.address == distinctaddresses[i]) {
2015-05-04 07:53:29 +00:00
found = true;
break;
}
}
2015-05-15 04:58:13 +00:00
if (!found) {
2015-07-01 16:10:20 +00:00
distinctaddresses.push(user.address);
}
if (user.login) {
regaddresses.push(user.address);
var found = false;
for (var i = 0; i < distinctregaddresses.length; i++) {
if (user.address == distinctregaddresses[i]) {
found = true;
break;
}
}
if (!found) {
distinctregaddresses.push(user.address);
}
2015-06-01 10:04:25 +00:00
}
2015-05-04 07:53:29 +00:00
});
User.getUserCount(function (err, regcount) {
if (err) {
2015-07-01 16:10:20 +00:00
logger.error('get status failed: ' + err);
2015-05-04 07:53:29 +00:00
return;
}
if (callback)
callback({
onlineNotes: Object.keys(notes).length,
onlineUsers: Object.keys(users).length,
distinctOnlineUsers: distinctaddresses.length,
notesCount: data.rows[0].count,
registeredUsers: regcount,
2015-07-01 16:10:20 +00:00
onlineRegisteredUsers: regaddresses.length,
distinctOnlineRegisteredUsers: distinctregaddresses.length,
isConnectionBusy: isConnectionBusy,
connectionSocketQueueLength: connectionSocketQueue.length,
isDisconnectBusy: isDisconnectBusy,
disconnectSocketQueueLength: disconnectSocketQueue.length
2015-05-04 07:53:29 +00:00
});
});
});
}
function getNotenameFromSocket(socket) {
if (!socket || !socket.handshake || !socket.handshake.headers) {
return;
}
var referer = socket.handshake.headers.referer;
if (!referer) {
return socket.disconnect(true);
}
var hostUrl = url.parse(referer);
2015-05-04 07:53:29 +00:00
var notename = hostUrl.pathname.split('/')[1];
if (notename == config.featuresnotename) {
return notename;
}
if (!Note.checkNoteIdValid(notename)) {
socket.emit('info', {
code: 404
});
return socket.disconnect(true);
2015-05-04 07:53:29 +00:00
}
notename = LZString.decompressFromBase64(notename);
return notename;
}
function emitOnlineUsers(socket) {
var notename = getNotenameFromSocket(socket);
if (!notename || !notes[notename]) return;
var users = [];
Object.keys(notes[notename].users).forEach(function (key) {
var user = notes[notename].users[key];
if (user)
2015-06-01 10:04:25 +00:00
users.push(buildUserOutData(user));
2015-05-04 07:53:29 +00:00
});
2015-07-01 16:10:20 +00:00
var out = {
users: users
};
out = LZString.compressToUTF16(JSON.stringify(out));
realtime.io.to(notename).emit('online users', out);
/*
2015-07-01 16:10:20 +00:00
for (var i = 0, l = notes[notename].socks.length; i < l; i++) {
var sock = notes[notename].socks[i];
if (sock && out)
sock.emit('online users', out);
};
*/
2015-06-01 10:04:25 +00:00
}
function emitUserStatus(socket) {
var notename = getNotenameFromSocket(socket);
if (!notename || !notes[notename]) return;
2015-07-01 16:10:20 +00:00
var out = buildUserOutData(users[socket.id]);
socket.broadcast.to(notename).emit('user status', out);
/*
2015-07-01 16:10:20 +00:00
for (var i = 0, l = notes[notename].socks.length; i < l; i++) {
var sock = notes[notename].socks[i];
2015-06-01 10:04:25 +00:00
if (sock != socket) {
sock.emit('user status', out);
}
2015-07-01 16:10:20 +00:00
};
*/
2015-07-01 16:10:20 +00:00
}
function emitRefresh(socket) {
var notename = getNotenameFromSocket(socket);
if (!notename || !notes[notename]) return;
var note = notes[notename];
socket.emit('refresh', {
docmaxlength: config.documentmaxlength,
2015-07-01 16:10:20 +00:00
owner: note.owner,
ownerprofile: note.ownerprofile,
lastchangeuser: note.lastchangeuser,
lastchangeuserprofile: note.lastchangeuserprofile,
2015-07-01 16:10:20 +00:00
permission: note.permission,
createtime: note.createtime,
2015-07-01 16:10:20 +00:00
updatetime: note.updatetime
2015-05-04 07:53:29 +00:00
});
}
function clearSocketQueue(queue, socket) {
for (var i = 0; i < queue.length; i++) {
if (!queue[i] || queue[i].id == socket.id) {
queue.splice(i, 1);
i--;
}
}
}
2015-05-04 07:53:29 +00:00
var isConnectionBusy = false;
var connectionSocketQueue = [];
var isDisconnectBusy = false;
var disconnectSocketQueue = [];
function finishConnection(socket, note, user) {
if (!socket || !note || !user) return;
//check view permission
if (note.permission == 'private') {
if (socket.request.user && socket.request.user.logged_in && socket.request.user._id == note.owner) {
//na
} else {
socket.emit('info', {
code: 403
});
clearSocketQueue(connectionSocketQueue, socket);
isConnectionBusy = false;
return socket.disconnect(true);
}
}
note.users[socket.id] = user;
note.socks.push(socket);
note.server.addClient(socket);
note.server.setName(socket, user.name);
note.server.setColor(socket, user.color);
2015-05-04 07:53:29 +00:00
emitOnlineUsers(socket);
2015-07-01 16:10:20 +00:00
emitRefresh(socket);
2015-05-04 07:53:29 +00:00
//clear finished socket in queue
clearSocketQueue(connectionSocketQueue, socket);
2015-05-04 07:53:29 +00:00
//seek for next socket
isConnectionBusy = false;
if (connectionSocketQueue.length > 0)
startConnection(connectionSocketQueue[0]);
if (config.debug) {
var notename = getNotenameFromSocket(socket);
2015-07-01 16:10:20 +00:00
logger.info('SERVER connected a client to [' + notename + ']:');
logger.info(JSON.stringify(user));
2015-07-01 16:10:20 +00:00
//logger.info(notes);
2015-05-04 07:53:29 +00:00
getStatus(function (data) {
2015-07-01 16:10:20 +00:00
logger.info(JSON.stringify(data));
2015-05-04 07:53:29 +00:00
});
}
}
function startConnection(socket) {
if (isConnectionBusy) return;
isConnectionBusy = true;
var notename = getNotenameFromSocket(socket);
if (!notename) {
clearSocketQueue(connectionSocketQueue, socket);
isConnectionBusy = false;
return;
}
2015-05-04 07:53:29 +00:00
if (!notes[notename]) {
db.readFromDB(notename, function (err, data) {
if (err) {
socket.emit('info', {
code: 404
});
socket.disconnect(true);
2015-05-04 07:53:29 +00:00
//clear err socket in queue
clearSocketQueue(connectionSocketQueue, socket);
2015-05-04 07:53:29 +00:00
isConnectionBusy = false;
2015-07-01 16:10:20 +00:00
return logger.error(err);
2015-05-04 07:53:29 +00:00
}
2015-07-01 16:10:20 +00:00
var owner = data.rows[0].owner;
var ownerprofile = null;
//find or new note
Note.findOrNewNote(notename, owner, function (err, note) {
2015-07-01 16:10:20 +00:00
if (err) {
responseError(res, "404", "Not Found", "oops.");
clearSocketQueue(connectionSocketQueue, socket);
isConnectionBusy = false;
2015-07-01 16:10:20 +00:00
return;
}
2015-07-01 16:10:20 +00:00
var body = LZString.decompressFromBase64(data.rows[0].content);
//body = LZString.compressToUTF16(body);
var createtime = data.rows[0].create_time;
2015-07-01 16:10:20 +00:00
var updatetime = data.rows[0].update_time;
var server = new ot.EditorSocketIOServer(body, [], notename, ifMayEdit);
var lastchangeuser = note.lastchangeuser || null;
var lastchangeuserprofile = null;
2015-07-01 16:10:20 +00:00
notes[notename] = {
id: notename,
2015-07-01 16:10:20 +00:00
owner: owner,
ownerprofile: ownerprofile,
2015-07-01 16:10:20 +00:00
permission: note.permission,
lastchangeuser: lastchangeuser,
lastchangeuserprofile: lastchangeuserprofile,
2015-07-01 16:10:20 +00:00
socks: [],
users: {},
createtime: moment(createtime).valueOf(),
updatetime: moment(updatetime).valueOf(),
server: server
2015-07-01 16:10:20 +00:00
};
async.parallel([
function getlastchangeuser(callback) {
if (lastchangeuser) {
//find last change user profile if lastchangeuser exists
User.findUser(lastchangeuser, function (err, user) {
if (!err && user && user.profile) {
var profile = JSON.parse(user.profile);
if (profile) {
lastchangeuserprofile = {
name: profile.displayName || profile.username,
photo: User.parsePhotoByProfile(profile)
}
notes[notename].lastchangeuserprofile = lastchangeuserprofile;
}
}
callback(null, null);
});
} else {
callback(null, null);
}
},
function getowner(callback) {
if (owner && owner != "null") {
//find owner profile if owner exists
User.findUser(owner, function (err, user) {
if (!err && user && user.profile) {
var profile = JSON.parse(user.profile);
if (profile) {
ownerprofile = {
name: profile.displayName || profile.username,
photo: User.parsePhotoByProfile(profile)
}
notes[notename].ownerprofile = ownerprofile;
}
}
callback(null, null);
});
} else {
callback(null, null);
}
}
], function(err, results){
if (err) return;
finishConnection(socket, notes[notename], users[socket.id]);
});
2015-07-01 16:10:20 +00:00
});
2015-05-04 07:53:29 +00:00
});
} else {
finishConnection(socket, notes[notename], users[socket.id]);
2015-05-04 07:53:29 +00:00
}
}
function disconnect(socket) {
if (isDisconnectBusy) return;
isDisconnectBusy = true;
if (config.debug) {
2015-07-01 16:10:20 +00:00
logger.info("SERVER disconnected a client");
logger.info(JSON.stringify(users[socket.id]));
2015-05-04 07:53:29 +00:00
}
2015-05-04 07:53:29 +00:00
if (users[socket.id]) {
delete users[socket.id];
}
var notename = getNotenameFromSocket(socket);
var note = notes[notename];
if (note) {
delete note.users[socket.id];
2015-07-01 16:10:20 +00:00
do {
var index = note.socks.indexOf(socket);
2015-07-01 16:10:20 +00:00
if (index != -1) {
note.socks.splice(index, 1);
2015-07-01 16:10:20 +00:00
}
} while (index != -1);
if (Object.keys(note.users).length <= 0) {
if (note.server.isDirty) {
var body = note.server.document;
2015-07-01 16:10:20 +00:00
var title = Note.getNoteTitle(body);
title = LZString.compressToBase64(title);
body = LZString.compressToBase64(body);
db.saveToDB(notename, title, body,
function (err, result) {
delete notes[notename];
if (config.debug) {
//logger.info(notes);
getStatus(function (data) {
logger.info(JSON.stringify(data));
});
}
});
} else {
delete notes[notename];
}
2015-05-04 07:53:29 +00:00
}
}
emitOnlineUsers(socket);
//clear finished socket in queue
clearSocketQueue(disconnectSocketQueue, socket);
2015-05-04 07:53:29 +00:00
//seek for next socket
isDisconnectBusy = false;
if (disconnectSocketQueue.length > 0)
disconnect(disconnectSocketQueue[0]);
if (config.debug) {
2015-07-01 16:10:20 +00:00
//logger.info(notes);
2015-05-04 07:53:29 +00:00
getStatus(function (data) {
2015-07-01 16:10:20 +00:00
logger.info(JSON.stringify(data));
2015-05-04 07:53:29 +00:00
});
}
}
2015-06-01 10:04:25 +00:00
function buildUserOutData(user) {
var out = {
id: user.id,
login: user.login,
userid: user.userid,
2015-07-04 14:19:09 +00:00
photo: user.photo,
2015-06-01 10:04:25 +00:00
color: user.color,
cursor: user.cursor,
name: user.name,
idle: user.idle,
type: user.type
};
return out;
}
function updateUserData(socket, user) {
//retrieve user data from passport
if (socket.request.user && socket.request.user.logged_in) {
var profile = JSON.parse(socket.request.user.profile);
user.photo = User.parsePhotoByProfile(profile);
2015-06-01 10:04:25 +00:00
user.name = profile.displayName || profile.username;
user.userid = socket.request.user._id;
user.login = true;
} else {
user.userid = null;
user.name = 'Guest ' + chance.last();
user.login = false;
}
}
2015-05-04 07:53:29 +00:00
function ifMayEdit(socket, callback) {
var notename = getNotenameFromSocket(socket);
if (!notename || !notes[notename]) return;
var note = notes[notename];
var mayEdit = true;
switch (note.permission) {
case "freely":
//not blocking anyone
break;
case "editable":
//only login user can change
if (!socket.request.user || !socket.request.user.logged_in)
mayEdit = false;
break;
case "locked": case "private":
//only owner can change
if (note.owner != socket.request.user._id)
mayEdit = false;
break;
}
//if user may edit and this note have owner (not anonymous usage)
if (socket.origin == 'operation' && mayEdit && note.owner && note.owner != "null") {
//save for the last change user id
if (socket.request.user && socket.request.user.logged_in) {
note.lastchangeuser = socket.request.user._id;
} else {
note.lastchangeuser = null;
}
}
callback(mayEdit);
}
2015-05-04 07:53:29 +00:00
function connection(socket) {
2015-06-01 10:04:25 +00:00
//split notename from socket
var notename = getNotenameFromSocket(socket);
//initialize user data
//random color
var color = randomcolor({
luminosity: 'light'
});
//make sure color not duplicated or reach max random count
if (notename && notes[notename]) {
var randomcount = 0;
var maxrandomcount = 5;
var found = false;
do {
Object.keys(notes[notename].users).forEach(function (user) {
if (user.color == color) {
found = true;
return;
}
});
if (found) {
color = randomcolor({
luminosity: 'light'
});
randomcount++;
}
} while (found && randomcount < maxrandomcount);
}
//create user data
2015-05-04 07:53:29 +00:00
users[socket.id] = {
id: socket.id,
address: socket.handshake.address,
'user-agent': socket.handshake.headers['user-agent'],
2015-06-01 10:04:25 +00:00
color: color,
2015-05-04 07:53:29 +00:00
cursor: null,
2015-06-01 10:04:25 +00:00
login: false,
userid: null,
name: null,
idle: false,
type: null
2015-05-04 07:53:29 +00:00
};
2015-06-01 10:04:25 +00:00
updateUserData(socket, users[socket.id]);
2015-05-04 07:53:29 +00:00
2015-06-01 10:04:25 +00:00
//start connection
2015-05-04 07:53:29 +00:00
connectionSocketQueue.push(socket);
startConnection(socket);
2015-07-01 16:10:20 +00:00
//received client refresh request
socket.on('refresh', function () {
emitRefresh(socket);
});
2015-06-01 10:04:25 +00:00
//received user status
2015-05-04 07:53:29 +00:00
socket.on('user status', function (data) {
2015-06-01 10:04:25 +00:00
var notename = getNotenameFromSocket(socket);
2015-07-01 16:10:20 +00:00
if (!notename || !notes[notename]) return;
2015-06-01 10:04:25 +00:00
if (config.debug)
2015-07-01 16:10:20 +00:00
logger.info('SERVER received [' + notename + '] user status from [' + socket.id + ']: ' + JSON.stringify(data));
2015-06-01 10:04:25 +00:00
if (data) {
var user = users[socket.id];
user.idle = data.idle;
user.type = data.type;
}
emitUserStatus(socket);
2015-05-04 07:53:29 +00:00
});
2015-07-01 16:10:20 +00:00
//received note permission change request
socket.on('permission', function (permission) {
//need login to do more actions
if (socket.request.user && socket.request.user.logged_in) {
var notename = getNotenameFromSocket(socket);
if (!notename || !notes[notename]) return;
var note = notes[notename];
//Only owner can change permission
if (note.owner == socket.request.user._id) {
note.permission = permission;
Note.findNote(notename, function (err, _note) {
if (err || !_note) {
return;
}
Note.updatePermission(_note, permission, function (err, _note) {
if (err || !_note) {
return;
}
var out = {
permission: permission
};
realtime.io.to(note.id).emit('permission', out);
2015-07-01 16:10:20 +00:00
for (var i = 0, l = note.socks.length; i < l; i++) {
var sock = note.socks[i];
if (typeof sock !== 'undefined' && sock) {
//check view permission
if (permission == 'private') {
if (sock.request.user && sock.request.user.logged_in && sock.request.user._id == note.owner) {
//na
} else {
sock.emit('info', {
code: 403
});
return sock.disconnect(true);
}
}
}
}
2015-07-01 16:10:20 +00:00
});
});
}
}
});
2015-06-01 10:04:25 +00:00
//reveiced when user logout or changed
socket.on('user changed', function () {
2015-07-01 16:10:20 +00:00
logger.info('user changed');
2015-06-01 10:04:25 +00:00
var notename = getNotenameFromSocket(socket);
if (!notename || !notes[notename]) return;
updateUserData(socket, notes[notename].users[socket.id]);
2015-05-04 07:53:29 +00:00
emitOnlineUsers(socket);
});
2015-06-01 10:04:25 +00:00
//received sync of online users request
socket.on('online users', function () {
var notename = getNotenameFromSocket(socket);
if (!notename || !notes[notename]) return;
var users = [];
Object.keys(notes[notename].users).forEach(function (key) {
var user = notes[notename].users[key];
if (user)
users.push(buildUserOutData(user));
});
var out = {
users: users
};
out = LZString.compressToUTF16(JSON.stringify(out));
socket.emit('online users', out);
});
//check version
2015-05-04 07:53:29 +00:00
socket.on('version', function () {
socket.emit('version', config.version);
});
2015-06-01 10:04:25 +00:00
//received cursor focus
2015-05-04 07:53:29 +00:00
socket.on('cursor focus', function (data) {
var notename = getNotenameFromSocket(socket);
if (!notename || !notes[notename]) return;
users[socket.id].cursor = data;
2015-06-01 10:04:25 +00:00
var out = buildUserOutData(users[socket.id]);
socket.broadcast.to(notename).emit('cursor focus', out);
/*
2015-07-01 16:10:20 +00:00
for (var i = 0, l = notes[notename].socks.length; i < l; i++) {
var sock = notes[notename].socks[i];
2015-05-04 07:53:29 +00:00
if (sock != socket) {
sock.emit('cursor focus', out);
}
2015-07-01 16:10:20 +00:00
};
*/
2015-05-04 07:53:29 +00:00
});
2015-06-01 10:04:25 +00:00
//received cursor activity
2015-05-04 07:53:29 +00:00
socket.on('cursor activity', function (data) {
var notename = getNotenameFromSocket(socket);
if (!notename || !notes[notename]) return;
users[socket.id].cursor = data;
2015-06-01 10:04:25 +00:00
var out = buildUserOutData(users[socket.id]);
socket.broadcast.to(notename).emit('cursor activity', out);
/*
2015-07-01 16:10:20 +00:00
for (var i = 0, l = notes[notename].socks.length; i < l; i++) {
var sock = notes[notename].socks[i];
2015-05-04 07:53:29 +00:00
if (sock != socket) {
sock.emit('cursor activity', out);
}
2015-07-01 16:10:20 +00:00
};
*/
2015-05-04 07:53:29 +00:00
});
2015-06-01 10:04:25 +00:00
//received cursor blur
2015-05-04 07:53:29 +00:00
socket.on('cursor blur', function () {
var notename = getNotenameFromSocket(socket);
if (!notename || !notes[notename]) return;
users[socket.id].cursor = null;
2015-06-01 10:04:25 +00:00
var out = {
id: socket.id
};
socket.broadcast.to(notename).emit('cursor blur', out);
/*
2015-07-01 16:10:20 +00:00
for (var i = 0, l = notes[notename].socks.length; i < l; i++) {
var sock = notes[notename].socks[i];
2015-05-04 07:53:29 +00:00
if (sock != socket) {
2015-07-01 16:10:20 +00:00
sock.emit('cursor blur', out);
2015-05-04 07:53:29 +00:00
}
2015-07-01 16:10:20 +00:00
};
*/
2015-05-04 07:53:29 +00:00
});
//when a new client disconnect
socket.on('disconnect', function () {
disconnectSocketQueue.push(socket);
disconnect(socket);
});
}
module.exports = realtime;