/**
* Routes
*/
// serve index and view partials
app.get('/', routes.index);
// app.get('/partials/:name', routes.partials);
// JSON API
app.get('/api/name', api.name);
// redirect all others to the index (HTML5 history)
app.get('*', routes.index);
/**
* Start Server
*/
var server = http.createServer(app);
io = io.listen(server);
server.listen(app.get('port'), function () {
console.log('Express server listening on port ' + app.get('port'));
});
// io.listen(server);
io.sockets.on('connection', function (socket) {
socket.emit('hello', {welcome: "Hi, I'm text from a socket!"});
});
socket.on('message:send', function(data) {
io.sockets.emit('message:receive', { message: data.message });
});
socket.on('client_connected', function(data){
data.id = socket.id;
m_players[i] = data;
i++;
io.sockets.emit("send_data", m_players)
});
app.use(express.errorHandler());
}
app.get('/', function(req, res){
res.render('index', { title: 'Dibujemos' });
});
io.set('log level', 1);
io.sockets.on('connection', function (socket) {
connections++;
console.log('connected', connections);
socket.broadcast.emit('connections', {connections:connections});
socket.on('cmove', function (data) {
socket.broadcast.emit('move', data);
});
socket.on('cchat', function (data) {
socket.broadcast.emit('chat', data);
});
socket.on('disconnect', function() {
connections--;
console.log('connected', connections);
socket.broadcast.emit('connections', {connections:connections});
});
});
server.listen(app.get('port'), function(){
console.log('Express server listening on port ' + app.get('port'));
});
,description: ''
,author: ''
,analyticssiteid: 'XXXXXXX'
,error: err
},status: 500 });
}
});
server.listen( port);
//Setup Socket.IO
var io = io.listen(server);
io.sockets.on('connection', function(socket){
console.log('Client Connected');
socket.on('message', function(data){
socket.broadcast.emit('server_message',data);
socket.emit('server_message',data);
});
socket.on('disconnect', function(){
console.log('Client Disconnected.');
});
});
///////////////////////////////////////////
// Routes //
///////////////////////////////////////////
/////// ADD ALL YOUR ROUTES HERE /////////
server.get('/', function(req,res){
res.render('index.jade', {
locals : {
socket.on("updateHealthConnectorToCreator", function (data) {
if (checkFriend(data))
io.sockets.socket(connections[data.friend].id).emit("updateHealthConnectorToCreator", {total: data.total});
});
socket.on("exitConnectorToCreator", function (data) {
if (checkFriend(data))
io.sockets.socket(connections[data.friend].id).emit("exitConnectorToCreator");
});
if(_curHL) {
//console.log("emit: "+returnHeadline(curH)+ " edit: "+curH.edit);
client.emit('initHeadline', { title: returnHeadline(_curHL), edit: _curHL.edit, replacements: _edits });
// TODO push most recent edits
} else {
selectHeadline( function(err) {
if(err) console.log(err.message);
client.emit('initHeadline', { title: returnHeadline(_curHL), edit: _curHL.edit, replacements: _edits });
});
}
});
// disocnnection function for all namespaces
io.sockets.on('disconnect', function () {
util.log('Client Disconnected');
});
// send message to all clients /all /main
function messageAllClients(t, s){
space_all.emit( t, s ); // e.g. 'newSubmission', s
space_main.emit( t, s );
// ... and broadcast it to everyone (except for the socket that started it)
}
// --------------------------------------------------
// Headline Selection
// --------------------------------------------------
io.sockets.on('connection',function (socket) {
// used in index.html
console.log('connection begun');
var child1 = spawn('sox',['-r', '44100', '-t', 'raw','-e','unsigned-integer','-b', '16','-','-r', '16k','-t', 'raw','-e', 'unsigned-integer','-b','16','-']);
// Error handling for process termination
child1.on('close', function (code) {
if (code !== 0) {
console.log('child1 process exited with code ' + code);
}
});
child1.stderr.on('data', function (data) {
console.log(' stderr: ' + data);
});
// Here comes the pipeline from index.html
// Get the sound as floats between -1 and 1, scale to 16 bits unsigned i.e. 0 ... 65535
// build a buffer of bytes, i.e. high end byte, low end byte
// turn it into a string using code cribbed from the web and pass it to sox
socket.on('data', function (data) {
// console.log(data);
console.log("passing to sox with rate " + data.rate);
// take the sound data
var sendthis = data.audio;
var packedform = [];
for (x in sendthis) {
var byte = 32767 * sendthis[x] + 32768;
var hi = (byte & 0xff00) >> 8;
var lo = byte & 0xff;
packedform.push(hi);
packedform.push(lo);
}
child1.stdin.write(String.fromCharCode.apply(null, packedform));
});
child1.stdout.on('data', function (data){
console.log("sox output data, writing to kaldi");
var client = new net.Socket();
client.connect(3000,function(){
client.write(data);
console.log('connected to 3000 :)');
});
client.on('data', function(data2){
console.log('DATA: ' + data2);
console.log('TEXT: ' + data2.toString());
// fs.readFile(__dirname+"/index.html", function(error,data3){
// if (error) {
// console.log('error');
// }
// rep.writeHead(200, {'Content-Type':'text/html'});
// rep.write(data3, 'utf8');
// rep.write(data2.toString());
// rep.end();
// });
}).on('error', function(err){
if (err.code == 'ECONNREFUSED') {
console.log('refused at 3000');
client.connect(10, function(){
console.log('CONNECTED TO 3000: next take');
});
}else {
console.log('ERR: ' + err);
}
}).on('close', function(){
console.log('connection to 3000 closed');
});
});
//used in offline.html
socket.on('wav', function (data) {
fs.writeFile('speech.wav', data.str, 'binary');
// run the kaldi decode script
// using the king solomon models
var child = spawn('bash', ['../scripts/offline_king_sol.sh']);
child.stdout.on('data', function(chunk) {
// need to parse buffer data bytes into ascii
var returnedText = chunk.toString();
console.log(returnedText);
// send back to html file to display for user
socket.emit("decode", {'result': returnedText});
});
});
});
io.sockets.on('connection', function (socket) {
socket.emit('usernames', usernames);
socket.on('user message', function (msg) {
socket.broadcast.emit('user message', socket.username, msg);
});
//console.log(io.sockets["in"]("game:508eaffc594eca8f40000003").clients());
socket.on('userLoggedIn', function (user, fn) {
console.log("received username: "******"").toLowerCase();
usernames[user] = socket.username = user;
socket.broadcast.emit('announcement', {
title: user + ' connected.'
});
io.sockets.emit('usernames', usernames);
/*}*/
});
socket.on('userLoggedOut', function (user, fn) {
if (!socket.username) return;
if(fn) fn(false);
delete usernames[socket.username];
socket.broadcast.emit('announcement', {
title: user + ' disconnected.'
});
io.sockets.emit('usernames', usernames);
});
socket.on("adminBroadcast", function(data){
if(data.secret !== "1gfhsjkyei764mkfme0jjd") return;
delete data.secret;
io.sockets.emit('announcement', data);
});
socket.on('game:subscribe', function(data) { socket.join("game:"+data.id); });
socket.on('game:unsubscribe', function(data) { socket.leave("game:"+data.id); });
socket.on('game:cardAction', function(data, fn) {
var gameId = data.gameId,
actionType = data.actionType,
actionData = data.actionData;
switch(actionType){
case "move":
Card.findByIdAndUpdate(actionData.cardId, { $set: { position: actionData.position }}).exec(function(err){
if(err){
fn(false);
return logger.error(err);
}
broadcastGameMessage(socket, "cardAction", gameId, actionType, actionData);
if(actionData.drop){
Game.findById(gameId, function(err, game){
var action = new GameAction({
type: "cardDrop",
data: {
card: actionData.cardId,
position: actionData.position
},
_game: gameId
});
action.save();
game.actions.push(action);
game.save();
});
}
fn(true);
});
break;
case "flip":
Card.findByIdAndUpdate(actionData.cardId, { $set: { face: actionData.face }}).exec(function(err){
if(err){
fn(false);
return logger.error(err);
}
broadcastGameMessage(socket, "cardAction", gameId, actionType, actionData);
fn(true);
});
break;
case "play":
Game.findById(gameId, "players decks table")
.populate("players.profile", "username")
.populate("players.hand")
.exec(function(err, game){
if(err){
fn(false);
return logger.error(err);
}
var activePlayer = _.find(game.players, function(player){
return (player.profile.username || "").toLowerCase() === (actionData.player || "").toLowerCase();
});
if(activePlayer){
var player = game.players.id(activePlayer);
var card = _.find(player.hand, function(card){
console.log(card._id);
console.log(actionData.cardId);
console.log(card._id.toString() === actionData.cardId.toString());
return card._id.toString() === actionData.cardId.toString();
});
console.log(card);
if(card){
player.hand.remove(card._id);
card.position = actionData.position;
card.save();
game.table.push(card);
game.save(function(err){
if(err){
fn(false);
return logger.error(err);
}
actionData.card = card.toJSON();
broadcastGameMessage(socket, "cardAction", gameId, actionType, actionData);
fn(true);
});
}
}
});
break;
case "take":
Game.findById(gameId, "players decks table")
.populate("players.profile", "username")
.populate("players.hand")
.populate("table")
.exec(function(err, game){
if(err){
fn(false);
return logger.error(err);
}
var activePlayer = _.find(game.players, function(player){
return (player.profile.username || "").toLowerCase() === (actionData.player || "").toLowerCase();
});
if(activePlayer){
var player = game.players.id(activePlayer);
var card = _.find(game.table, function(card){
console.log(card._id);
console.log(actionData.cardId);
console.log(card._id.toString() === actionData.cardId.toString());
return card._id.toString() === actionData.cardId.toString();
});
console.log(card);
if(card){
game.table.remove(card._id);
/*card.position = actionData.position;
card.save();*/
player.hand.push(card);
game.save(function(err){
if(err){
fn(false);
return logger.error(err);
}
//actionData.card = card.toJSON();
broadcastGameMessage(socket, "cardAction", gameId, actionType, actionData);
fn(true);
});
}
}
});
break;
default:
logger.error("received unrecognized cardAction: "+data.actionType);
break;
}
});
socket.on('game:playerMouseMove', function(data, fn){
var gameId = data.gameId,
actionType = data.actionType,
actionData = data.actionData;
broadcastGameMessage(socket, "playerMouseMove", gameId, actionType, actionData);
//socket.broadcast.to("game:"+gameId).emit('game:playerMouseMove', data);
});
socket.on('disconnect', function () {
if (!socket.username) return;
delete usernames[socket.username];
socket.broadcast.emit('announcement', {
title: socket.username + ' disconnected.'
});
socket.broadcast.emit('usernames', usernames);
});
});
socket.on("adminBroadcast", function(data){
if(data.secret !== "1gfhsjkyei764mkfme0jjd") return;
delete data.secret;
io.sockets.emit('announcement', data);
});
_.delay(function () {
io.sockets.emit('stop', users);
}, conf.viewDelay);
io.sockets.on('connection', function(socket) {
// ---------------------------------- //
// Enregistrement des utilisateurs //
// ---------------------------------- //
socket.on('login', function(user) {
if (socket.username) {
socket.emit('error',"Vous ne pouvez pas changer de nom de joueur.");
} else if (user.data == "" || users[user.data]) {
socket.emit('error', "Ce nom de joueur est déjà utilisé.");
} else {
users[user.data] = {
score : 0,
game : []
}
socket.username = user.data;
socket.emit('registerUser', socket.username);
io.sockets.emit('updateUsers', users);
}
});
// ---------------------------------- //
// Enregistrement des propositions //
// ---------------------------------- //
socket.on('guessTitle', function(guess) {
if (!socket.username || !guess.user || socket.username !== guess.user) {
socket.emit('error',"Vous n'êtes pas un joueur connu.");
} else if (!users[socket.username].game[gameState - 1] ||
!users[socket.username].game[gameState - 1].success) {
var film = game[gameState - 1].answer;
var user = users[socket.username];
if (film.test(guess.data)) {
user.game[gameState - 1] = {
time: +new Date,
success: true
};
user.score++;
socket.emit('success', true);
socket.emit('status', user);
} else {
user.game[gameState - 1] = {
time: +new Date,
success: false
};
socket.emit('success', false);
}
}
});
// ---------------------------------- //
// Demarrage du jeu //
// ---------------------------------- //
socket.on('start', function() {
io.sockets.emit('start');
_.each(users, function (element, index, list) {
users[index].score = 0;
users[index].game = [];
});
gameState = 0;
updateView();
});
// ---------------------------------- //
// Enchainement des écrans du jeu //
// ---------------------------------- //
// L'application envoie l'évènement //
// updateView toute les viewDelay //
// millisecondes jusqu'a ce que tous //
// Les écran aient été passés en //
// revue. //
// ---------------------------------- //
function updateView(){
var data = {
view: gameState,
film: game[gameState]
}
_.each(users, function (element, index, list) {
users[index].game[gameState] = {
time: +new Date,
success: false
};
});
io.sockets.emit('updateView', data);
gameState++;
if(gameState < game.length) {
_.delay(updateView, conf.viewDelay);
} else {
_.delay(function () {
io.sockets.emit('stop', users);
}, conf.viewDelay);
}
}
});
io.sockets.on('connection', function (socket) {
// on a join, add them to the right board and save that
// property on their socket.
socket.on('join', function(data) {
db.collection('boards').find({name: data.board}).sort({time: 1}).toArray(function(err, actions) {
if (actions.length == 0) {
socket.emit('draw', {points:[]})
}
actions.forEach(function(action) {
socket.emit(action.verb, {
points: action.points
})
})
socket.set('board', data.board)
socket.join(data.board)
});
});
// On a message, broadcast it to everyone in their board.
socket.on('draw', function(data) {
socket.get('board', function(err, board){
insertPoints(board,data.points)
socket.broadcast.to(board).emit('draw', data)
})
})
socket.on('erase', function(data) {
socket.get('board', function(err, board){
removePoints(board,data.points)
socket.broadcast.to(board).emit('erase', data)
})
})
socket.on('clear', function(data) {
socket.get('board', function(err, board){
removeAllPoints(board)
socket.broadcast.to(board).emit('clear', data)
})
})
});
socket.on("movementConnectorToCreator", function (data) {
if (checkFriend(data))
io.sockets.socket(connections[data.friend].id).volatile.emit("movementConnectorToCreator", {x: data.x, y: data.y});
});
(function(){
var express = require('express')
, routes = require('./routes')
, http = require('http')
, path = require('path')
, io = require('socket.io')
, fs = require('fs')
, crypto = require('crypto');
var server = {
server_msg: 'JunctionServerExecution/current/MSG/smsg.txt'
, server_msg_uri: '/JunctionServerExecution/current/MSG/smsg.txt'
, server_path: 'JunctionServerExecution/current/MSG/'
, server_base_text: 'basetext.txt'
, question_uri: "/JunctionServerExecution/current/"
, isOnline: false
, socket: {}
}
var users = { };
//Configure server
var app = express();
app.configure(function(){
app.set('port', process.env.PORT || 80);
app.set('views', __dirname + '/views');
app.set('view engine', 'ejs');
app.use(express.favicon());
//app.use(express.logger('dev'));
app.use(express.bodyParser());
app.use(express.methodOverride());
app.use(express.cookieParser('your secret here'));
app.use(express.session());
app.use(app.router);
app.use(require('stylus').middleware(__dirname + '/public'));
app.use(express.static(path.join(__dirname, 'public')));
});
app.configure('development', function(){
app.use(express.errorHandler());
});
//Define routes
app.post('/JunctionServerExecution/pushmsg.php', function(req, res){
var fname = 'MSG'+crypto.randomBytes(4).readUInt32LE(0)+'';
var content = "" + req.body.MSG;
fs.writeFile(server.server_path + fname, content, function (err) {
if (err) throw res.send(404);
res.send(req.body.MSG);
});
});
app.get('/JunctionServerExecution/current/MSG/smsg.txt', function(req, res){
fs.readFile(server.server_msg, function (err, data) {
if (err) throw err;
res.type('application/json');
res.send(data);
});
});
app.get("/JunctionServerExecution/current/", function (req, res){
res.send(" OK ");
});
//INDEX
app.get('/', function(req, res){
res.render('index', { server: req.headers.host , port: app.get('port'), ip: req.connection.remoteAddress });
});
app.get('/wait', function(req, res){
fs.readFile(server.server_base_text, 'utf-8', function(err, data){
if(err) res.send(500);
else{
res.render('wait', { server: req.headers.host , port: app.get('port'), ip: req.connection.remoteAddress, basetext: data });
}
});
});
app.get('/waitresult', function(req, res){
res.render('wait_result',{ server: req.headers.host , port: app.get('port'), ip: req.connection.remoteAddress});
});
app.get('/make', function(req, res){
res.render('make', { server: req.headers.host , port: app.get('port'), ip: req.connection.remoteAddress });
});
app.get('/solve', function(req, res){
fs.readFile(server.server_msg,'utf-8', function (err, data) {
if(err){
res.send(500);
return;
}
sv = JSON.parse(data);
var server_ip = req.headers.host;
var user_ip = req.connection.remoteAddress;
res.render('solve', {
question_uri: 'http://' + server_ip + server.question_uri
, numq: sv.NUMQ
, username: users[user_ip].name
, user_ip: user_ip
});
});
});
app.get('/results', function(req, res){
fs.readFile(server.server_msg,'utf-8', function (err, svdata) {
if(err) { res.send(500, "ERROR READING SV STATUS"); return; }
fs.readFile(server.server_path + req.connection.remoteAddress + '.txt','utf-8', function (err, usrdata) {
if(err) { res.send(500, "ERROR READING USER STATUS"); return; }
var sv = JSON.parse(svdata);
var usr = JSON.parse(usrdata);
if(sv.TYPE != "START_SHOW"){
res.send(404, "Not done yet, the current status is " + sv.TYPE);
}
res.render('results', {
server: req.headers.host
, port: app.get('port')
, ip: req.connection.remoteAddress
, serverStatus: sv
, userStatus: usr
, question_uri: 'http://' + req.headers.host + server.question_uri
, userStatus: usr});
});
});
});
app.get('/basetext', function(req, res){
fs.readFile(server.server_base_text, 'utf-8', function(err, data){
if(err) { res.send(500, err); return; }
res.render('basetext', { server: req.headers.host , port: app.get('port'), ip: req.connection.remoteAddress, text: data, writeSuccess: false });
});
});
app.post('/basetext', function(req, res){
var unorm = require('unorm');
var text = req.body.base_text;
var password = req.body.password;
if (password != "senhaprotegida"){
res.render('basetext',{text: text, writeSuccess: false});
}
var regex = /[\u0300-\u036F]/g;
text = unorm.nfkd(text).replace(regex, '');
fs.writeFile(server.server_base_text, text, 'utf-8', function(err){
if(err) { res.send(500); return; }
res.render('basetext',{text: text, writeSuccess: true});
});
});
app.post('/sobek', function(req, res){
var client = req.connection.remoteAddress + '.txt';
var exec = require('child_process').exec;
var unorm = require('unorm');
var buffer = '';
var text = req.body.texto;
var regex = /[\u0300-\u036F]/g;
text = unorm.nfkd(text).replace(regex, '');
function baseTextCallback(error, stdout, stderr) {
fs.unlink(client, function(err){
if (err) { res.send(500, "ERROR ON PARSING BASETEXT"); return;}
buffer += stdout;
res.charset = 'utf-8';
res.send(buffer.split('\n').join(' '));
})
}
fs.writeFile(client, text, function(err){
if (err){ res.send(500); return;}
exec("java -jar sobek.jar " + client , function(err, stdout, stderr){
if(err) { res.send(500, "ERROR ON PARSING CLIENT TEXT"); return; }
buffer += stdout;
exec("java -jar sobek.jar basetext.txt",baseTextCallback);
});
});
//EXECUTAR DUAS VEZES O SOBEK. UMA COM O TEXTO BASE E OUTRA COM A QUESTÃO.
//PEGAR N CONCEITOS DE CADA UMA E MANDAR PARA O USUARIO
});
app.get("/JunctionServerExecution/current/:q", function(req, res, next){
fs.readFile("JunctionServerExecution/current/" + req.params.q, 'utf-8', function(err, data){
if(err){
res.send(404);
return;
}else{
res.send(data);
}
});
});
//Start Server
var sv = http.createServer(app);
var io = require('socket.io').listen(sv);
sv.listen(app.get('port'), function(){
console.log('SERVER STARTED ON PORT ' + app.get('port'))
});
sv.on('error', function (e) {
if (e.code == 'EADDRINUSE') {
console.log('PORT 80 in use. Trying the port 8080' );
app.set('port', 8080);
setTimeout(function () {
sv.listen(app.get('port'));
}, 1000);
}
});
io.set('log level', 0);
//Listener for server msgs file
fs.watchFile(server.server_msg, function (curr, prev) {
fs.readFile(server.server_msg, 'utf-8', function (err, data) {
if (err) {
io.sockets.emit('server_changed', "SERVER OFFLINE");
server.isOnline = false;
}else{
io.sockets.emit('server_changed', "SERVER ONLINE");
var status = JSON.parse(data);
io.sockets.emit(status.TYPE, status);
server.isOnline = true;
//io.sockets.emit('changestatus', data);
}
});
});
// Listener for users first connection
io.sockets.on('connection', function (socket) {
var teacherMsg;
var userIp = socket.handshake.address.address;
fs.readFile(server.server_msg,'utf-8', function (err, data) {
if (err){
socket.emit('server_changed', "SERVER OFFLINE");
socket.emit('displayError', "SERVER OFFLINE");
server.isOnline = false;
return;
}
socket.emit('server_changed', "SERVER ONLINE");
teacherMsg = JSON.parse(data);
server.isOnline = true;
fs.readFile(server.server_path + userIp + '.txt','utf-8', function (err, data) {
if(err) { console.log('NEW USER AT ' + userIp); return; }
var usrMsg = JSON.parse(data);
console.log(usrMsg.NAME + " has been reconected");
socket.user = {
name: usrMsg.NAME
, ip: userIp
, teacherMsg: teacherMsg
};
users[userIp] = socket.user;
socket.emit("restore_state", {name: usrMsg.NAME, ip: userIp, teacherMsg: teacherMsg, loged: true});
});
});
socket.on('login', function(data, fnAck){
fs.readFile(server.server_msg,'utf-8', function (err, teacherData) {
if (err){
socket.emit('displayError', "SERVER OFFLINE");
return;
}
teacherMsg = JSON.parse(teacherData);
//Registra o usuario para o JunctionServer
var fname = 'MSG'+crypto.randomBytes(4).readUInt32LE(0)+'';
data.MSG.IP = userIp;
var content = JSON.stringify(data.MSG);
fs.writeFile(server.server_path + fname, content, function (err) {
if (err) throw error;
socket.user = {
name: data.MSG.NAME
, socket: socket
, ip: userIp
, teacherMsg: teacherMsg
};
socket.emit(teacherMsg.TYPE, {
name: socket.user.name
, ip: socket.user.ip
, teacherMsg: teacherMsg
, loged: true
});
console.log(data.MSG.NAME + " LOGED ON IP " + data.MSG.IP );
users[userIp] = socket.user;
fnAck(data.MSG);
socket.emit(teacherMsg.TYPE, teacherMsg);
});
});
});
socket.on('get_server_state', function(){
fs.readFile(server.server_msg,'utf-8', function (err, teacherData) {
if(err){
socket.emit('displayError', "SERVER OFFLINE");
return;
}
var teacherMsg = JSON.parse(teacherData);
console.log("RESTORING " + teacherMsg.TYPE)
socket.emit(teacherMsg.TYPE);
});
});
socket.on('question', function(data){});
socket.on('solve', function(data){});
});
})()
socket.on("damageConnectorToCreator", function (data) {
if (checkFriend(data))
io.sockets.socket(connections[data.friend].id).emit("damageConnectorToCreator", {enemy: data.enemy, damage: data.damage});
});
var fs = require('fs');
var http = require('http');
var fsmonitor = require('fsmonitor')
var io = require('socket.io');
var server = http.createServer(function(req, res){
fs.readFile('index.html', 'utf8', function(err,data){
res.writeHead(200, {'Content-Type': 'text/html'})
res.end(data)
})
}).listen(3000);
io = io.listen(server);
io.sockets.on('connection', function(socket){
fs.readFile('data.txt', 'utf8', function(err,data){
io.sockets.emit('ack', {message:data});
});
fsmonitor.watch('/home/famasya/Works/nodejs/watchfile',null, function(change){
fs.readFile('data.txt', 'utf8', function(err,data){
//cross check
if(change.modifiedFiles[0] == 'data.txt'){
io.sockets.emit('ack', {message:data});
}
})
})
});
console.log('listening on 3000');
socket.on("updateHealthConnectorToCreatorACK", function (data) {
if (checkFriend(data))
io.sockets.socket(connections[data.friend].id).emit("updateHealthConnectorToCreatorACK", {healths: data.healths});
});
fs.readFile('data.txt', 'utf8', function(err,data){
io.sockets.emit('ack', {message:data});
});
io.sockets.on('connection', function(socket){
var address = socket.handshake.address;
var room;
var gObj;
console.log("New connection from " + address.address + ":" + address.port);
socket.on('join_room', function(room_to_join){
//joins socket to a room
room = room_to_join;
socket.join(room.room+'_'+room.type);
console.log(room.ip+" joined room: "+room.room+'_'+room.type);
if(room.type == 'client'){
//gObj = {country: 'Portugal', latitude:Math.floor(Math.random()*37), longitude:-1*Math.floor(Math.random()*122)};
var gObj = ipinfodb.ip2geo(room.ip,function(gObj){
console.log("Country: " + gObj.country);
console.log("Lat: " + gObj.latitude);
console.log("Long: " + gObj.longitude);
console.log("Long: " + gObj.longitude);
socket.broadcast.to(room.room+'_world').emit('location',gObj);
console.log('location was broadcasted to room: ' + room.room + '_world');
});
}
});
socket.on('disconnect', function(){
//check wich type of user left the room. if its a world_room user, it does nothing. otherwise...
socket.leave("/"+room.room+'_'+room.type);
console.log("Leaving room: " + room.room+' Type:'+room.type);
if(room.type == 'client'){
socket.broadcast.to(room.room+'_world').emit('disconnected',gObj);
console.log("user disconnected");
}
// console.log("user disconnected from room:" + room.room + ". sending obj...");
});
socket.on('my other event', function(data){
console.log(data);
});
});
fs.readFile('data.txt', 'utf8', function(err,data){
//cross check
if(change.modifiedFiles[0] == 'data.txt'){
io.sockets.emit('ack', {message:data});
}
})
app.use(express.bodyParser());
app.use(express.cookieParser());
app.use(express.session({secret: '223454354350AETHER'}));
app.use(app.router);
//Configure the server to use the client-folder:
//app.set('client', __dirname+'/client');
app.configure(function() {
app.use(express.static(__dirname + '/client'));
app.use(express.static(__dirname + '/bower_components'));
});
app.use('/', express.static(__dirname + '/client/'));
//socket:
io = io.listen(app.listen(process.env.PORT || 4730));
io.sockets.on('connection', function (socket) {
setInterval(function () {
socket.emit('message', { action: 'sendPositionUpdate' });
}, 1000);
socket.emit('message', { action: 'connected' });
socket.on('status update', function (msg) {
console.log(msg);
});
});
io.sockets.on('disconnect', function (socket) {
socket.emit('message', { action: 'disconnect' });
});
console.log('error');
} else {
//console.log('success');
}
});
});
});
} else {
console.log("Usage : node app.js (link)");
process.exit();
}
app.get('/', function(req, res){
res.sendfile(html + 'index.html');
});
var server = http.createServer(app).listen(app.get('port'), function(){
console.log('Express server listening on port ' + app.get('port'));
});
io = io.listen(server);
io.sockets.on('connection', function(socket) {
var files = fs.readdirSync('html/myimg');
var i = 0;
for (i = 0; i<files.length; i++){
socket.emit('affiche', {link: files[i]});
}
});
var zmqSocket = zmq.socket('sub');
zmqSocket.identity = 'subscriber' + process.pid;
zmqSocket.connect(port);
zmqSocket.subscribe('');
var express = require("express");
var io = require('socket.io');
var app = express(),
server = require('http').createServer(app),
io = io.listen(server);
server.listen(8080);
// Set up place for static files
app.use("/public", express.static(__dirname + '/public'));
app.get('/', function (req, res) {
res.sendfile(__dirname + '/index.html');
});
io.sockets.on('connection', function (socket) {
zmqSocket.on('message',
function(data) {
console.log("received frame");
socket.emit('frame', {
frame: JSON.parse(data)
});
});
});
io.sockets.on('connection', function(socket) {
// Take in ID from upload track client
socket.on('id', function(id) {
socket._id = id;
});
// Emit progress to upload track client
socket.on('uploadProgress', function() {
socket.emit('progress', progress[socket._id]);
});
// Take in ID from musicpage client and listen for changes in rating
socket.on('rating_id', function(id) {
// Use the follow module to listen for changes in the database
var options = { db: "https://everton.iriscouch.com/dischost", include_docs: true, since: "now" };
follow(options, function(error, change) {
if(!error) {
io.sockets.emit('update', change.doc);
}
});
});
/*// Request feed from couchDB, callback on response
https.get(host + path, function(response) {
response.setEncoding('ascii');
var message = ""; //variable that builds the string of chunks
response.on('data', function(chunk) {
message += chunk;
var update = JSON.parse(message);
// if the updated doc ID is the same as the rating ID sent by the client
if(update.id == id) {
console.log("getting document...");
// Create another request to get updated document
https.get(host + '/dischost/' + id, function(docResp) {
// When response is returned, send to all connected clients
docResp.setEncoding('ascii');
docResp.on('data', function(doc) {
});
});
}
});
});*/
socket.on('disconnect', function() {
console.log('socket disconnected');
});
});
io.sockets.on('connection', function(socket) {
console.log("New connection: " + socket);
socket.on('client_connected', function(data){
data.id = socket.id;
m_players[i] = data;
i++;
io.sockets.emit("send_data", m_players)
});
socket.on('update_coords', function(pos){
for(var x=0; x < m_players.length; x++)
{
if (m_players[x].id == socket.id)
{
m_players[x].x = pos.x;
m_players[x].y = pos.y;
console.log("Client: " + socket.id);
console.log("X: " + pos.x + ", Y: " + pos.y );
break;
}
}
io.sockets.emit("send_data", m_players);
});
socket.on('disconnect', function()
{
var j = 0;
var n = 0;
var tmp = [];
while (n < m_players.length)
{
if (m_players[j].id == socket.id)
n++;
if (n < m_players.length)
{
tmp[j] = m_players[n];
j++;
n++;
}
}
m_players = tmp;
i = j;
io.sockets.emit('send_data', m_players);
});
});
follow(options, function(error, change) {
if(!error) {
io.sockets.emit('update', change.doc);
}
});
function deleteMeal (id) {
for(var i = 0; i < meals.length; i++) {
if (meals[i].id == parseInt(id)) {
meals.splice(i,1);
return;
}
}
}
function getInitialData(){
return meals;
}
io.sockets.on('connection',function (socket) {
console.log('A user connected!');
socket.emit('initData', getInitialData());
socket.on('sellMeal',function(data){
if (!data.name.match(/[a-zA-Z]+/)) return;
if (data.name.length < 3) return;
var new_food_item = createMeal(data);
io.sockets.emit('newMeal',new_food_item);
});
socket.on('delMeal',function(id){
// note, this is not authenticated
deleteMeal(id);
socket.broadcast.emit('delMeal',id);
});
});
socket.on('disconnect', function () {
clients = io.sockets.clients();
console.log("Socket disconnected");
io.sockets.emit('pageview', { 'connections': Object.keys(io.connected).length});
console.log(clients.length + " clients are connected");
});