Socket.io ExpressJS chat rooms

app.js

var express = require('express');
var http = require('http');
var path = require('path');
var logger = require('morgan');
var cookieParser = require('cookie-parser');
var bodyParser = require('body-parser');

var app = express();
var server = http.Server(app);
var io = require('socket.io')(server);

var routes = require('./routes/index');
var users = require('./routes/users');
var rooms = require('./routes/rooms');
app.set('port', 8000);

server.listen(app.get('port'), function() {
  console.log("Boo");
});

// view engine setup
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'jade');

app.use(logger('dev'));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));
app.use(cookieParser());
app.use(express.static(path.join(__dirname, 'public')));

app.use('/', routes);
app.use('/users', users);
app.use('/rooms', rooms);

app.get('/index', function(req, res, next) {
  res.render("index");
})
// catch 404 and forward to error handler
app.use(function(req, res, next) {
    var err = new Error('Not Found');
    err.status = 404;
    next(err);
});

// error handlers

// development error handler
// will print stacktrace
if (app.get('env') === 'development') {
    app.use(function(err, req, res, next) {
        res.status(err.status || 500);
        res.render('error', {
            message: err.message,
            error: err
        });
    });
}

// production error handler
// no stacktraces leaked to user
app.use(function(err, req, res, next) {
    res.status(err.status || 500);
    res.render('error', {
        message: err.message,
        error: {}
    });
});

var usernames = [];

function findClientsSocket(roomId, namespace) {
  var res = []
  , ns = io.of(namespace ||"/");

  if (ns) {
    for (var id in ns.connected) {
      if(roomId) {
        var index = ns.connected[id].rooms.indexOf(roomId) ;
        if(index !== -1) {
          res.push(ns.connected[id]);
        }
      } else {
        res.push(ns.connected[id]);
      }
    }
  }
  return res;
}

var chat = io.of('/rooms').on('connection', function(socket) {

  socket.emit('pong', "connected")
  socket.on('ping', function(data) {
    console.log(data)
  });

  socket.on('load', function(data) {
    var room = findClientsSocket(io, data.room, '/rooms')
    console.log(data, usernames)
    if(data.username) {
      if(usernames.indexOf(data.username) === -1) {
        socket.username = data.username
        socket.room = data.room
        socket.active = true;
        socket.join(data.room)
        usernames.push(socket.username)
        socket.emit('log_message', { success: true })
        }
    }

    chat.in(data.room).emit('peopleInChat', {
      boolean: true,
      roomId: data.room,
      users: usernames
    });
  });

  socket.on('login', function(data) {
    var room = findClientsSocket(io, data.room, '/rooms')
    if(usernames.indexOf(data.username) === -1) {
      socket.emit('log_message', { success: false, message: 'user name exists'})
    } else {
      socket.username = data.username
      //socket.updated_at = data.id
      socket.room = data.room
      socket.active = true

      socket.join(data.room);

      if(room.length >= 0) {
        usernames.push(socket.username);
        console.log(usernames);
        socket.emit('log_message', { success: true })
      }

      chat.in(data.room).emit('peoplInChat', {
        boolean: true,
        roomId: data.room,
        users: usernames
      });
    }
  });

  socket.on('disconnect', function() {
    usernames.splice(usernames.indexOf(this.username), 1)
    socket.broadcast.to(this.room).emit('leave', {
      room: this.room,
      user: this.username
    });
    socket.leave(socket.room)
  });

  socket.on('message', function(data){
    console.log(data, socket.room)
    socket.broadcast.to(socket.room).emit('receive', {
      content: data.content,
      user: data.user
    });
  });
});

chats.js

var socket = io.connect('/rooms', { port: 8000, transports: ['websocket']});

function getRoomId() {
  return window.location.pathname.match(/\/rooms\/(\d+)$/)[1]
}

function checkLoginStatus(name) {
  var foo = sessionStorage.getItem("user");
  if(foo) {
    return name == JSON.parse(foo).username ? name : JSON.parse(foo).username
  }
  return false;
}

(function() {
  var username = checkLoginStatus();
  if(username) {
    $(".loginForm").style.display="none";
    $(".chatWindow").style.display="block";
  }
  socket.on('connect', function(data) {
    socket.emit('load', {
      username: username || $(".username").value,
      room: getRoomId()
    });
  });

})()

socket.on('peopleInChat', function(data){
  console.log(data);
});

socket.on('leave', function(data) {
  console.log(data, "left");
});

$("#login").onclick = function(e) {
  e.preventDefault();
  var formData = {};
  formData["username"] = $(".username").value;
  formData["uid"] = Date.now();
  formData["room"] = getRoomId()

  sessionStorage.setItem("user", JSON.stringify(formData))
  socket.emit("login", formData)

  socket.on('log_message', function(data) {
    if(data.success) {
      $(".loginForm").style.display="none";
      $(".chatWindow").style.display="block";
      if(data.messages) {
        $(".logs").innerHTML = data.message
      }
    }
  });

  socket.on('startChat', function(data) {
    console.log(data);
  });

  return false;
}

$("#sendMessage").onclick = function(e) {
  e.preventDefault();
  var messageData = {};
  messageData["content"] = $(".content").value
  messageData["user"] = checkLoginStatus()

  socket.emit('message', messageData);
}

socket.on('receive', function(data) {
  console.log(data)
})

room_list.js

$('#room').onclick = function(e) {
  e.preventDefault();
  $.get("/rooms", "json").then(function(data) {
    var html = "", template;
    template =  "<div style='font-size: 20px'>" +
      "<strong><a href='rooms/{{id}}'>{{room}}</a></strong>" +
      "</div>";

    var rooms = data.rooms;
    for(var r in rooms) {
      html += Mustache(template, rooms[r])
    }
    $(".rooms").innerHTML = html;
  }).catch(function(err) {
    console.log("Error!!")
  });
}

rooms.jade

extends layout

block content
  .row
    .col-md-12.logs
      form.loginForm
        .form-group
          label(for='nickname') Nickname
          input(type='text', class='form-control', name='username')
          input(type='submit', value='Enter', id='login')
   .row.chatWindow
     .col-md-8
       .messages
       .messageForm

     .col-md-4
       .users

   script(type="text/javascript", src="/javascripts/chats.js")

www

#!/usr/bin/env node

/**
 * Module dependencies.
 */

var app = require('../app');
var debug = require('debug')('chathall:server');
var http = require('http');
var io = require('../libs/io');

/**
 * Get port from environment and store in Express.
 */

var port = normalizePort(process.env.PORT || '8000');
app.set('port', port);

/**
 * Create HTTP server.
 */

//var server = http.createServer(app);

/**
 * Listen on provided port, on all network interfaces.
 * server.listen(port);
 * server.on('error', onError);
 * server.on('listening', onListening);
 */

var server = app.listen(app.get('port'), function() {
  debug('Express server listening on port ' + server.address().port)
});

io.attach(server)

/**
 * Normalize a port into a number, string, or false.
 */

function normalizePort(val) {
  var port = parseInt(val, 10);

  if (isNaN(port)) {
    // named pipe
    return val;
  }

  if (port >= 0) {
    // port number
    return port;
  }

  return false;
}

/**
 * Event listener for HTTP server "error" event.
 */

function onError(error) {
  if (error.syscall !== 'listen') {
    throw error;
  }

  var bind = typeof port === 'string'
    ? 'Pipe ' + port
    : 'Port ' + port

  // handle specific listen errors with friendly messages
  switch (error.code) {
    case 'EACCES':
      console.error(bind + ' requires elevated privileges');
      process.exit(1);
      break;
    case 'EADDRINUSE':
      console.error(bind + ' is already in use');
      process.exit(1);
      break;
    default:
      throw error;
  }
}

/**
 * Event listener for HTTP server "listening" event.
 */

function onListening() {
  var addr = server.address();
  var bind = typeof addr === 'string'
    ? 'pipe ' + addr
    : 'port ' + addr.port;
  debug('Listening on ' + bind);
}