drewdiddy611's Solution'

.gitignore

@@ -0,0 +1,2 @@
+/node_modules/
+.env

README.md

@@ -1,2 +1 @@
-# project_superchat
-Build a realtime multi-room chat application. Make it super.
+Andrew Senner and Benny Soung

app.js

@@ -0,0 +1,52 @@
+var express = require('express');
+var path = require('path');
+var favicon = require('serve-favicon');
+var logger = require('morgan');
+var cookieParser = require('cookie-parser');
+var bodyParser = require('body-parser');
+var exphbs = require('express-handlebars');
+
+var index = require('./routes/index');
+var login = require('./routes/login');
+var users = require('./routes/users');
+var room = require('./routes/room');
+
+var app = express();
+
+// view engine setup
+app.engine('handlebars', exphbs({ defaultLayout: 'main' }));
+app.set('views', path.join(__dirname, 'views'));
+app.set('view engine', 'handlebars');
+
+// uncomment after placing your favicon in /public
+//app.use(favicon(path.join(__dirname, 'public', 'favicon.ico')));
+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('/', index);
+app.use('/login', login);
+app.use('/users', users);
+app.use('/room', room);
+
+// 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 handler
+app.use(function(err, req, res, next) {
+	// 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');
+});
+
+module.exports = app;

bin/www

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+
+/**
+ * Module dependencies.
+ */
+
+const express = require('express');
+var app = require('../app');
+var debug = require('debug')('project-superchat:server');
+var http = require('http');
+
+/**
+ * Get port from environment and store in Express.
+ */
+
+var port = normalizePort(process.env.PORT || '3000');
+app.set('port', port);
+
+/**
+ * Create HTTP server.
+ */
+
+var server = http.createServer(app);
+
+/**
+ * Create socket server.
+ */
+app.use(
+	'/socket.io',
+	express.static(__dirname + 'node_modules/socket.io-client/dist/')
+);
+const io = require('socket.io')(server);
+const socketWrapper = require('../lib/socket_wrapper');
+io.on('connection', socketWrapper(io));
+
+/**
+ * Listen on provided port, on all network interfaces.
+ */
+server.listen(port);
+server.on('error', onError);
+server.on('listening', onListening);
+
+/**
+ * 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:
+			console.error(error.stack);
+			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);
+}

db.js

@@ -0,0 +1,10 @@
+const { saveModule } = require('./lib/redis_wrapper');
+const { saveUser, saveMessage, saveRoom } = saveModule;
+
+const { hashSync: encodePassword } = require('bcryptjs');
+
+for (let r = 0; r < 5; r++) {
+	saveRoom({
+		roomname: `An Awesome Room ${r + 1}`
+	});
+}

lib/redis_wrapper/index.js

@@ -0,0 +1,11 @@
+// Require modules.
+const redis = require('redis');
+
+// Promisify everything.
+const Promise = require('bluebird');
+Promise.promisifyAll(redis.RedisClient.prototype);
+
+module.exports = {
+	loadModule: require('./load_module'),
+	saveModule: require('./save_module')
+};

lib/redis_wrapper/load_module/get_messages_by_type_id.js

@@ -0,0 +1,25 @@
+let redisClient = require('redis');
+
+if (process.env.ENV_NODE && process.env.ENV_NODE === 'production') {
+	redisClient = redisClient.createClient(process.env.REDIS_URL);
+} else {
+	redisClient = redisClient.createClient(process.env.REDIS_URL);
+}
+
+const getModelData = require('./get_model_data');
+
+const _filterMessages = (type, typeId) => messages => {
+	type = type.slice(0, -1);
+	return messages.filter(msg => {
+		return +msg[`${type}_id`] === +typeId;
+	});
+};
+
+module.exports = function(type, typeId) {
+	if (typeId !== undefined && !isNaN(+typeId)) {
+		// Get all messages by their type id.
+		return getModelData('messages').then(_filterMessages(type, typeId));
+	} else {
+		return Promise.reject(Error('Invalid type id.'));
+	}
+};

lib/redis_wrapper/load_module/get_model_data.js

@@ -0,0 +1,63 @@
+let redisClient = require('redis');
+
+if (process.env.ENV_NODE && process.env.ENV_NODE === 'production') {
+	redisClient = redisClient.createClient(process.env.REDIS_URL);
+} else {
+	redisClient = redisClient.createClient(process.env.REDIS_URL);
+}
+
+// Generic function which handles getting model data from redis.
+module.exports = function(type, typeId) {
+	// Make sure we have a type at the very minimum.
+	if (type === undefined || typeof type !== 'string') return [];
+
+	// Did the user pass in an id or array of ids?
+	if (typeId !== undefined) {
+		if (!isNaN(+typeId)) {
+			// If typeId is a number, we're fetching
+			// a single entry of type.
+			return _fetchSingleType(type, typeId);
+		} else if (Array.isArray(typeId)) {
+			// If typeId is an array, we're fetching
+			// multiple entries of type, that correspond
+			// to the ids in the array.
+			return _fetchByTypeWithIds(type, typeId);
+		} else {
+			// Invalid parameter passed.
+			return Promise.reject(Error('Invalid argument type for typeId'));
+		}
+	}
+	// Grab all entries of a certain type.
+	return _grabAllByType(type);
+};
+
+// Get a single type from redis.
+function _fetchSingleType(type, id) {
+	return redisClient.hgetallAsync(`${type}:${id}`).then(type => {
+		return type ? [type] : [];
+	});
+}
+
+// Get multiple of type from redis.
+function _fetchByTypeWithIds(type, typeIds) {
+	// Fetch all entries of type.
+	return _grabAllByType(type).then(entries => {
+		// Filter through results and only keep
+		// entries that are in the typeIds array.
+		return entries.filter(type => {
+			return typeIds.includes(type.id);
+		});
+	});
+}
+
+// Grab all by a certain type (helper);
+function _grabAllByType(type) {
+	return redisClient.keysAsync(`${type}:*`).then(_getTypeData);
+}
+
+// Gets corresponding entries in redis from _grabAllByType.
+function _getTypeData(typeKeys) {
+	return Promise.all(
+		typeKeys.map(typeKey => redisClient.hgetallAsync(typeKey))
+	);
+}

lib/redis_wrapper/load_module/get_users_by_room_id.js

@@ -0,0 +1,20 @@
+let redisClient = require('redis');
+
+if (process.env.ENV_NODE && process.env.ENV_NODE === 'production') {
+	redisClient = redisClient.createClient(process.env.REDIS_URL);
+} else {
+	redisClient = redisClient.createClient(process.env.REDIS_URL);
+}
+
+const getModelData = require('./get_model_data');
+
+const _getUsersByRoom = roomId => users => {
+	if (!users || users.length === 0) return [];
+	return users.filter(user => +user.room_id === +roomId);
+};
+
+module.exports = function(roomId) {
+	if (roomId !== undefined && !isNaN(+roomId)) {
+		return getModelData('users').then(_getUsersByRoom(roomId));
+	}
+};

lib/redis_wrapper/load_module/index.js

@@ -0,0 +1,12 @@
+const getModelData = require('./get_model_data');
+const getMessagesByTypeId = require('./get_messages_by_type_id');
+
+module.exports = {
+	getUsers: id => getModelData('users', id),
+	getMessages: id => getModelData('messages', id),
+	getRooms: id => getModelData('rooms', id),
+	getMessagesByRoomId: id => getMessagesByTypeId('rooms', id),
+	getMessagesByUserId: id => getMessagesByTypeId('users', id),
+	getUsersByRoomId: require('./get_users_by_room_id'),
+	typeExists: require('./type_exists')
+};

lib/redis_wrapper/load_module/type_exists.js

@@ -0,0 +1,9 @@
+const getModelData = require('./get_model_data');
+
+module.exports = (dataType, name) => {
+	return getModelData(dataType).then(types => {
+		return types.some(
+			type => type[dataType.slice(0, -1).concat('name')] === name
+		);
+	});
+};

lib/redis_wrapper/save_module/index.js

@@ -0,0 +1,11 @@
+const saveModelData = require('./save_model_data');
+const updateTypeData = require('./update_type_data');
+
+module.exports = {
+	saveUser: data => saveModelData('users', data),
+	saveMessage: data => saveModelData('messages', data),
+	saveRoom: data => saveModelData('rooms', data),
+	updateUserData: (id, field, value) => {
+		return updateTypeData('users', id, field, value);
+	}
+};

lib/redis_wrapper/save_module/save_model_data.js

@@ -0,0 +1,38 @@
+let redisClient = require('redis');
+
+if (process.env.ENV_NODE && process.env.ENV_NODE === 'production') {
+	redisClient = redisClient.createClient(process.env.REDIS_URL);
+} else {
+	redisClient = redisClient.createClient(process.env.REDIS_URL);
+}
+
+const Promise = require('bluebird');
+// Data map to check for valid entries to be saved
+const dataMap = {
+	users: ['username', 'password', 'room_id'],
+	messages: ['body', 'gmt_created', 'user_id', 'room_id'],
+	rooms: ['roomname']
+};
+
+const _validateEntryData = data => type => {
+	return Object.keys(data).every(key => dataMap[type].includes(key));
+};
+
+// Generic function which handles saving model data to redis.
+module.exports = function(type, data) {
+	// console.log(data, "whats this");
+	if (type === undefined || typeof type !== 'string') {
+		return Promise.reject(Error('Invalid argument type for type'));
+	}
+	if (!_validateEntryData(data)(type)) {
+		return Promise.reject(
+			Error('Incorrect data structure passed, aborting save.')
+		);
+	}
+
+	// Increment our counter, then save our new entry.
+	return redisClient.incrAsync(`counts:${type}`).then(newId => {
+		data.id = newId;
+		return redisClient.hmsetAsync(`${type}:${data.id}`, data);
+	});
+};

lib/redis_wrapper/save_module/update_type_data.js

@@ -0,0 +1,11 @@
+let redisClient = require('redis');
+
+if (process.env.ENV_NODE && process.env.ENV_NODE === 'production') {
+	redisClient = redisClient.createClient(process.env.REDIS_URL);
+} else {
+	redisClient = redisClient.createClient(process.env.REDIS_URL);
+}
+
+module.exports = function(type, id, field, value) {
+	return redisClient.hsetAsync(`${type}:${id}`, field, value);
+};