Aaron Saloff's Project

.gitignore

@@ -0,0 +1 @@
+node_modules/

Procfile

@@ -0,0 +1 @@
+web: node app

README.md

@@ -1,2 +1,26 @@
-# project_superchat
-Build a realtime multi-room chat application. Make it super.
+# Realtime Chat App
+
+A realtime multi-room chat application built using Node/Express and websockets.
+
+![Superchat Demo](https://s3.amazonaws.com/demo-gifs-asaloff/superchat.gif)
+
+[Demo](https://node-express-live-chat.herokuapp.com) - (Hosted free on heroku and may be sleeping. Could take 30 seconds the first time to load)
+
+### Technologies Used
+
+- Node.js
+- Express.js
+- Redis (data store)
+- Bootstrap
+- Handlebars (view engine)
+- socket.io (realtime page updates)
+
+### Usage
+
+- Login using any username
+- Open two seperate browsers to see live chat updates
+
+Feel free to get in touch with any feedback or questions. [email protected]
+
+
+

app.js

@@ -0,0 +1,68 @@
+const express = require('express');
+const path = require('path');
+const logger = require('morgan');
+const morganToolkit = require('morgan-toolkit')(logger);
+const cookieParser = require('cookie-parser');
+const bodyParser = require('body-parser');
+const helpers = require('./helpers');
+const exphbs = require('express-handlebars');
+const redis = require('redis');
+const bluebird = require('bluebird');
+bluebird.promisifyAll(redis.RedisClient.prototype);
+bluebird.promisifyAll(redis.Multi.prototype);
+
+const index = require('./routes/index');
+
+const app = express();
+
+// view engine setup
+const hbs = exphbs.create({
+  helpers: helpers,
+  partialsDir: 'views/partials/',
+  defaultLayout: 'main.hbs',
+  extname: '.hbs'
+});
+
+app.engine('hbs', hbs.engine);
+app.set('view engine', 'hbs');
+app.set('Handlebars', hbs);
+
+app.use(bodyParser.json());
+app.use(bodyParser.urlencoded({ extended: false }));
+app.use(cookieParser());
+app.use(express.static(path.join(__dirname, 'public')));
+app.use('/socket.io',express.static(path.join(__dirname, 'node_modules/socket.io-client/dist/')));
+app.use(logger('short'));
+app.use(morganToolkit());
+
+app.use('/', index);
+
+// catch 404 and forward to error handler
+app.use((req, res, next) => {
+  var err = new Error('Not Found');
+  err.status = 404;
+  next(err);
+});
+
+// error handler
+app.use((err, req, res) => {
+  // set locals, only providing error in development
+  res.locals.message = err.message;
+  res.locals.error = req.app.get('env') === 'development' ? err : {};
+
+  // render the error page
+  res.status(err.status || 500);
+  res.render('error');
+});
+
+const server = require('http').createServer(app);
+const PORT = process.env.PORT || 3000;
+
+const io = require('socket.io').listen(server);
+
+server.listen(PORT, () => console.log(`Listening on ${ PORT }`));
+
+module.exports = { app, io };
+
+const socket = require('./lib/socket_service');
+socket.setup(io);

data_structure.md

@@ -0,0 +1,8 @@
+Redis Tables
+============
+
+**SET** - roomName: [username1, username2 ...] - for listing rooms with amount of members
+
+**SET** - 'users': [username1, username2 ...] - for adding new users and validating
+
+**HASH** 'messages:roomName:uniqueId': { body: string, author: username, room: roomName, createdAt: time }

helpers/debug_helper.js

@@ -0,0 +1,15 @@
+var HandlebarsDebugHelper = {};
+
+HandlebarsDebugHelper.debug = (optionalValue) => {
+  console.log("Current Context");
+  console.log("====================");
+  console.log(this);
+
+  if (optionalValue) {
+    console.log("Value");
+    console.log("====================");
+    console.log(optionalValue);
+  }
+};
+
+module.exports = HandlebarsDebugHelper;

helpers/index.js

@@ -0,0 +1,6 @@
+const HelperLoader = require('load-helpers');
+const helperLoader = new HelperLoader();
+
+const helpers = helperLoader.load('helpers/*_helper.js').cache;
+
+module.exports = helpers;

helpers/redisHelper.js

@@ -0,0 +1,17 @@
+const RedisHelper = {
+  createClient: () => {
+    const redis = require('redis');
+    let redisClient;
+    if (process.env.REDISTOGO_URL) {
+      var rtg   = require("url").parse(process.env.REDISTOGO_URL);
+      redisClient = redis.createClient(rtg.port, rtg.hostname);
+
+      redisClient.auth(rtg.auth.split(":")[1]);
+    } else {
+      redisClient = redis.createClient();
+    }
+    return redisClient;
+  }
+};
+
+module.exports = RedisHelper;

helpers/view_helper.js

@@ -0,0 +1,28 @@
+const Handlebars = require('handlebars');
+
+var viewHelper = {};
+
+const getFormattedTime = (d) => {
+  var hours = d.getUTCHours();
+  var minutes = d.getUTCMinutes();
+
+  // 0 padding for minutes under 10
+  if (minutes < 10) { minutes = `0${minutes}`; }
+
+  if (hours > 12) {
+    return `${ hours - 12 }:${minutes}pm UTC`;
+  } else {
+    return `${ hours }:${minutes}am UTC`;
+  }
+};
+
+viewHelper.formatDate = (d) => {
+  d = new Date(d);
+  return `${d.getMonth() + 1}/${d.getDate()}/${d.getFullYear()} ${getFormattedTime(d)}`;
+};
+
+viewHelper.addHr = (messages, message) => {
+  if (messages[0] !== message) return new Handlebars.SafeString('<hr>');
+};
+
+module.exports = viewHelper;

lib/chat_rooms.js

@@ -0,0 +1,76 @@
+const RedisHelper = require('../helpers/redisHelper');
+const redisClient = RedisHelper.createClient();
+
+var ChatRooms = {};
+
+ChatRooms.getAll = (username, activeRoom) => {
+  return new Promise(async (resolve, reject) => {
+
+    const chatRoomName = activeRoom.split('-').join(' ');
+
+    var allRooms = { username, chatRoomName, activeRoom };
+
+    allRooms.rooms = await getRooms(activeRoom);
+    var keys = await redisClient.keysAsync(`messages:${activeRoom}:*`);
+    allRooms.isMember = await checkUserMember(activeRoom, username);
+
+    if (keys.length === 0) {
+      resolve(allRooms);
+    }
+
+    var messages = [];
+
+    for (let key of keys) {
+      redisClient.hgetallAsync(key).then(message => {
+
+        messages.push(message);
+
+        if (messages.length === keys.length) {
+          allRooms.messages = messages.sort((a, b) => new Date(a.createdAt) - new Date(b.createdAt));
+          resolve(allRooms);
+        }
+      });
+    }
+  });
+};
+
+const getRooms = (activeRoom) => {
+  return new Promise((resolve, reject) => {
+    redisClient.smembers('users', (err, list) => {
+
+      var totalUsers = list.length;
+
+      redisClient.keys('room:*', (err, roomKeys) => {
+        var rooms = [];
+
+        if (!roomKeys.length) {
+          resolve(rooms);
+        }
+
+        roomKeys.forEach(roomKey => {
+          redisClient.smembers(roomKey, (err, members) => {
+
+            var slug = roomKey.slice(5);
+            var name = slug.split('-').join(' ');
+
+            rooms.push({ name: name, memberAmount: members.length, active: slug == activeRoom, slug: slug });
+
+            if (rooms.length === roomKeys.length) {
+              resolve(rooms);
+            }
+          });
+        });
+      });
+    });
+  });
+};
+
+const checkUserMember = (room, user) => {
+  return new Promise((resolve, reject) => {
+    redisClient.sismember(`room:${ room }`, user, (err, isMember) => {
+      resolve(isMember);
+    });
+  });
+};
+
+module.exports = ChatRooms;

lib/socket_service.js

@@ -0,0 +1,94 @@
+var Socket = {};
+
+Socket.setup = (io) => {
+  const { app } = require('../app');
+  const hbs = app.get('Handlebars');
+  const RedisHelper = require('../helpers/redisHelper');
+  const redisClient = RedisHelper.createClient();
+  const randomstring = require('randomstring');
+
+  const generateRandomString = () => {
+    return randomstring.generate({
+      length: 8,
+      charset: 'alphanumeric'
+    });
+  };
+
+  const createUniqueId = () => {
+    return new Promise((resolve, reject) => {
+      var string = generateRandomString();
+
+      redisClient.sismember('ids', string, (err, used) => {
+        if (used) {
+          createUniqueId()
+            .then((string) => {
+              resolve(string);
+            });
+        } else {
+          redisClient.sadd('ids', string);
+          resolve(string);
+        }
+      });
+    });
+  };
+
+  io.on('connection', client => {
+
+    console.log('Socket Connected');
+
+    client.on('new-message', async (info, username) => {
+      // generate unique id
+      var id = await createUniqueId();
+
+      var room = info.room.split(' ').join('-');
+
+      redisClient.hmset(`messages:${ room }:${ id }`, 'body', info.body, 'createdAt', info.createdAt, 'author', username, 'room', info.room );
+      var partial = await hbs.render(
+        'views/partials/message.hbs',
+        { body: info.body, createdAt: info.createdAt, author: username, leadingHr: info.leadingHr }
+      );
+
+      io.emit('render-message', partial, room);
+    });
+
+    client.on('new-room-name', (roomName, username) => {
+      var slug = roomName.trim().split(' ').join('-');
+      // check if exists
+      redisClient.smembers(`room:${ slug }`, async (err, members) => {
+        if (members.length) {
+          client.emit('room-name-taken');
+        } else {
+          redisClient.sadd(`room:${ slug }`, username);
+
+          // render partial
+          var partial = await hbs.render(
+            'views/partials/room.hbs',
+            { name: `${ roomName }`, memberAmount: 1, slug: slug }
+          );
+
+          io.emit('new-room', partial);
+        }
+      });
+    });
+
+    client.on('join-user', async (room, username) => {
+      await redisClient.sadd(`room:${ room }`, username);
+      handleMemberCounts(room);
+    });
+
+    client.on('leave-user', async (room, username) => {
+      await redisClient.srem(`room:${ room }`, username);
+      handleMemberCounts(room);
+    });
+
+    const handleMemberCounts = room => {
+      redisClient.smembers(`room:${ room }`, (err, members) => {
+        var memberCount = members.length;
+        client.emit('refresh');
+        io.emit('change-member-count', room, memberCount);
+      });
+    };
+  });
+};
+
+module.exports = Socket;

package.json

@@ -0,0 +1,26 @@
+{
+  "name": "project-superchat",
+  "version": "0.0.0",
+  "private": true,
+  "scripts": {
+    "start": "node app",
+    "debug": "node debug app"
+  },
+  "dependencies": {
+    "bluebird": "^3.5.1",
+    "body-parser": "~1.17.1",
+    "cookie-parser": "~1.4.3",
+    "debug": "~2.6.3",
+    "express": "^4.15.5",
+    "express-handlebars": "^3.0.0",
+    "hbs": "~4.0.1",
+    "load-helpers": "^1.0.1",
+    "morgan": "~1.8.1",
+    "morgan-toolkit": "^1.0.2",
+    "randomstring": "^1.1.5",
+    "redis": "^2.8.0",
+    "serve-favicon": "~2.4.2",
+    "socket.io": "^2.0.3",
+    "socket.io-client": "^2.0.3"
+  }
+}

public/javascripts/behavior.js

@@ -0,0 +1,18 @@
+$(document).ready(() => {
+  $('#new-chatroom').click(() => {
+    $('#newChat').modal('show');
+  });
+
+  $('#logout-link').click((e) => {
+    e.preventDefault();
+    $('#logout-form').submit();
+  });
+
+  $('.room-select').click((room) => {
+    var id = room.target.id;
+    var roomName = id.slice(5).split('-').join(' ');
+
+    document.cookie = `chatRoom=${ roomName }`;
+    document.location = '/';
+  });
+});