decaffeinate: Convert MessageFormatter.coffee and 6 other files to JS

services/chat/app/coffee/Features/Messages/MessageFormatter.js

@@ -1,46 +1,70 @@
-module.exports = MessageFormatter =
-	formatMessageForClientSide: (message) ->
-		if message._id?
-			message.id = message._id.toString()
-			delete message._id
-		formattedMessage =
-			id: message.id
-			content: message.content
-			timestamp: message.timestamp
+/*
+ * decaffeinate suggestions:
+ * DS101: Remove unnecessary use of Array.from
+ * DS102: Remove unnecessary code created because of implicit returns
+ * DS207: Consider shorter variations of null checks
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+let MessageFormatter;
+module.exports = (MessageFormatter = {
+	formatMessageForClientSide(message) {
+		if (message._id != null) {
+			message.id = message._id.toString();
+			delete message._id;
+		}
+		const formattedMessage = {
+			id: message.id,
+			content: message.content,
+			timestamp: message.timestamp,
 			user_id: message.user_id
-		if message.edited_at?
-			formattedMessage.edited_at = message.edited_at
-		return formattedMessage
+		};
+		if (message.edited_at != null) {
+			formattedMessage.edited_at = message.edited_at;
+		}
+		return formattedMessage;
+	},
 
-	formatMessagesForClientSide: (messages) ->
-		(@formatMessageForClientSide(message) for message in messages)
+	formatMessagesForClientSide(messages) {
+		return (Array.from(messages).map((message) => this.formatMessageForClientSide(message)));
+	},
 	
-	groupMessagesByThreads: (rooms, messages) ->
-		rooms_by_id = {}
-		for room in rooms
-			rooms_by_id[room._id.toString()] = room
+	groupMessagesByThreads(rooms, messages) {
+		let room, thread;
+		const rooms_by_id = {};
+		for (room of Array.from(rooms)) {
+			rooms_by_id[room._id.toString()] = room;
+		}
 
-		threads = {}
-		getThread = (room) ->
-			thread_id = room.thread_id.toString()
-			if threads[thread_id]?
-				return threads[thread_id]
-			else
-				thread = { messages: [] }
-				if room.resolved?
-					thread.resolved = true
-					thread.resolved_at = room.resolved.ts
-					thread.resolved_by_user_id = room.resolved.user_id
-				threads[thread_id] = thread
-				return thread
+		const threads = {};
+		const getThread = function(room) {
+			const thread_id = room.thread_id.toString();
+			if (threads[thread_id] != null) {
+				return threads[thread_id];
+			} else {
+				const thread = { messages: [] };
+				if (room.resolved != null) {
+					thread.resolved = true;
+					thread.resolved_at = room.resolved.ts;
+					thread.resolved_by_user_id = room.resolved.user_id;
+				}
+				threads[thread_id] = thread;
+				return thread;
+			}
+		};
 			
-		for message in messages
-			room = rooms_by_id[message.room_id.toString()]
-			if room?
-				thread = getThread(room)
-				thread.messages.push MessageFormatter.formatMessageForClientSide(message)
+		for (let message of Array.from(messages)) {
+			room = rooms_by_id[message.room_id.toString()];
+			if (room != null) {
+				thread = getThread(room);
+				thread.messages.push(MessageFormatter.formatMessageForClientSide(message));
+			}
+		}
 		
-		for thread_id, thread of threads
-			thread.messages.sort (a,b) -> a.timestamp - b.timestamp
+		for (let thread_id in threads) {
+			thread = threads[thread_id];
+			thread.messages.sort((a,b) => a.timestamp - b.timestamp);
+		}
 		
-		return threads
+		return threads;
+	}
+});

services/chat/app/coffee/Features/Messages/MessageHttpController.js

@@ -1,112 +1,151 @@
-logger = require "logger-sharelatex"
-metrics = require "metrics-sharelatex"
-MessageManager = require "./MessageManager"
-MessageFormatter = require "./MessageFormatter"
-ThreadManager = require "../Threads/ThreadManager"
-{ObjectId} = require "../../mongojs"
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * DS207: Consider shorter variations of null checks
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+let MessageHttpController;
+const logger = require("logger-sharelatex");
+const metrics = require("metrics-sharelatex");
+const MessageManager = require("./MessageManager");
+const MessageFormatter = require("./MessageFormatter");
+const ThreadManager = require("../Threads/ThreadManager");
+const {ObjectId} = require("../../mongojs");
 
-module.exports = MessageHttpController =
-	DEFAULT_MESSAGE_LIMIT: 50
-	MAX_MESSAGE_LENGTH: 10 * 1024 # 10kb, about 1,500 words
+module.exports = (MessageHttpController = {
+	DEFAULT_MESSAGE_LIMIT: 50,
+	MAX_MESSAGE_LENGTH: 10 * 1024, // 10kb, about 1,500 words
 	
-	getGlobalMessages: (req, res, next) ->
-		MessageHttpController._getMessages(ThreadManager.GLOBAL_THREAD, req, res, next)
+	getGlobalMessages(req, res, next) {
+		return MessageHttpController._getMessages(ThreadManager.GLOBAL_THREAD, req, res, next);
+	},
 
-	sendGlobalMessage: (req, res, next) ->
-		MessageHttpController._sendMessage(ThreadManager.GLOBAL_THREAD, req, res, next)
+	sendGlobalMessage(req, res, next) {
+		return MessageHttpController._sendMessage(ThreadManager.GLOBAL_THREAD, req, res, next);
+	},
 	
-	sendThreadMessage: (req, res, next) ->
-		MessageHttpController._sendMessage(req.params.thread_id, req, res, next)
+	sendThreadMessage(req, res, next) {
+		return MessageHttpController._sendMessage(req.params.thread_id, req, res, next);
+	},
 	
-	getAllThreads: (req, res, next) ->
-		{project_id} = req.params
-		logger.log {project_id}, "getting all threads"
-		ThreadManager.findAllThreadRooms project_id, (error, rooms) ->
-			return next(error) if error?
-			room_ids = rooms.map (r) -> r._id
-			MessageManager.findAllMessagesInRooms room_ids, (error, messages) ->
-				return next(error) if error?
-				threads = MessageFormatter.groupMessagesByThreads rooms, messages
-				res.json threads
+	getAllThreads(req, res, next) {
+		const {project_id} = req.params;
+		logger.log({project_id}, "getting all threads");
+		return ThreadManager.findAllThreadRooms(project_id, function(error, rooms) {
+			if (error != null) { return next(error); }
+			const room_ids = rooms.map(r => r._id);
+			return MessageManager.findAllMessagesInRooms(room_ids, function(error, messages) {
+				if (error != null) { return next(error); }
+				const threads = MessageFormatter.groupMessagesByThreads(rooms, messages);
+				return res.json(threads);
+			});
+		});
+	},
 	
-	resolveThread: (req, res, next) ->
-		{project_id, thread_id} = req.params
-		{user_id} = req.body
-		logger.log {user_id, project_id, thread_id}, "marking thread as resolved"
-		ThreadManager.resolveThread project_id, thread_id, user_id, (error) ->
-			return next(error) if error?
-			res.send 204 # No content
+	resolveThread(req, res, next) {
+		const {project_id, thread_id} = req.params;
+		const {user_id} = req.body;
+		logger.log({user_id, project_id, thread_id}, "marking thread as resolved");
+		return ThreadManager.resolveThread(project_id, thread_id, user_id, function(error) {
+			if (error != null) { return next(error); }
+			return res.send(204);
+		});
+	}, // No content
 
-	reopenThread: (req, res, next) ->
-		{project_id, thread_id} = req.params
-		logger.log {project_id, thread_id}, "reopening thread"
-		ThreadManager.reopenThread project_id, thread_id, (error) ->
-			return next(error) if error?
-			res.send 204 # No content
+	reopenThread(req, res, next) {
+		const {project_id, thread_id} = req.params;
+		logger.log({project_id, thread_id}, "reopening thread");
+		return ThreadManager.reopenThread(project_id, thread_id, function(error) {
+			if (error != null) { return next(error); }
+			return res.send(204);
+		});
+	}, // No content
 	
-	deleteThread: (req, res, next) ->
-		{project_id, thread_id} = req.params
-		logger.log {project_id, thread_id}, "deleting thread"
-		ThreadManager.deleteThread project_id, thread_id, (error, room_id) ->
-			return next(error) if error?
-			MessageManager.deleteAllMessagesInRoom room_id, (error) ->
-				return next(error) if error?
-				res.send 204 # No content
+	deleteThread(req, res, next) {
+		const {project_id, thread_id} = req.params;
+		logger.log({project_id, thread_id}, "deleting thread");
+		return ThreadManager.deleteThread(project_id, thread_id, function(error, room_id) {
+			if (error != null) { return next(error); }
+			return MessageManager.deleteAllMessagesInRoom(room_id, function(error) {
+				if (error != null) { return next(error); }
+				return res.send(204);
+			});
+		});
+	}, // No content
 	
-	editMessage: (req, res, next) ->
-		{content} = req?.body
-		{project_id, thread_id, message_id} = req.params
-		logger.log {project_id, thread_id, message_id, content}, "editing message"
-		ThreadManager.findOrCreateThread project_id, thread_id, (error, room) ->
-			return next(error) if error?
-			MessageManager.updateMessage room._id, message_id, content, Date.now(), (error) ->
-				return next(error) if error?
-				res.send(204)
+	editMessage(req, res, next) {
+		const {content} = req != null ? req.body : undefined;
+		const {project_id, thread_id, message_id} = req.params;
+		logger.log({project_id, thread_id, message_id, content}, "editing message");
+		return ThreadManager.findOrCreateThread(project_id, thread_id, function(error, room) {
+			if (error != null) { return next(error); }
+			return MessageManager.updateMessage(room._id, message_id, content, Date.now(), function(error) {
+				if (error != null) { return next(error); }
+				return res.send(204);
+			});
+		});
+	},
 
-	deleteMessage: (req, res, next) ->
-		{project_id, thread_id, message_id} = req.params
-		logger.log {project_id, thread_id, message_id}, "deleting message"
-		ThreadManager.findOrCreateThread project_id, thread_id, (error, room) ->
-			return next(error) if error?
-			MessageManager.deleteMessage room._id, message_id, (error, message) ->
-				return next(error) if error?
-				res.send(204)
+	deleteMessage(req, res, next) {
+		const {project_id, thread_id, message_id} = req.params;
+		logger.log({project_id, thread_id, message_id}, "deleting message");
+		return ThreadManager.findOrCreateThread(project_id, thread_id, function(error, room) {
+			if (error != null) { return next(error); }
+			return MessageManager.deleteMessage(room._id, message_id, function(error, message) {
+				if (error != null) { return next(error); }
+				return res.send(204);
+			});
+		});
+	},
 
-	_sendMessage: (client_thread_id, req, res, next) ->
-		{user_id, content} = req?.body
-		{project_id} = req.params
-		if !ObjectId.isValid(user_id)
-			return res.send(400, "Invalid user_id")
-		if !content?
-			return res.send(400, "No content provided")
-		if content.length > @MAX_MESSAGE_LENGTH
-			return res.send(400, "Content too long (> #{@MAX_MESSAGE_LENGTH} bytes)")
-		logger.log {client_thread_id, project_id, user_id, content}, "new message received"
-		ThreadManager.findOrCreateThread project_id, client_thread_id, (error, thread) ->
-			return next(error) if error?
-			MessageManager.createMessage thread._id, user_id, content, Date.now(), (error, message) ->
-				return next(error) if error?
-				message = MessageFormatter.formatMessageForClientSide(message)
-				message.room_id = project_id
-				res.send(201, message)
+	_sendMessage(client_thread_id, req, res, next) {
+		const {user_id, content} = req != null ? req.body : undefined;
+		const {project_id} = req.params;
+		if (!ObjectId.isValid(user_id)) {
+			return res.send(400, "Invalid user_id");
+		}
+		if ((content == null)) {
+			return res.send(400, "No content provided");
+		}
+		if (content.length > this.MAX_MESSAGE_LENGTH) {
+			return res.send(400, `Content too long (> ${this.MAX_MESSAGE_LENGTH} bytes)`);
+		}
+		logger.log({client_thread_id, project_id, user_id, content}, "new message received");
+		return ThreadManager.findOrCreateThread(project_id, client_thread_id, function(error, thread) {
+			if (error != null) { return next(error); }
+			return MessageManager.createMessage(thread._id, user_id, content, Date.now(), function(error, message) {
+				if (error != null) { return next(error); }
+				message = MessageFormatter.formatMessageForClientSide(message);
+				message.room_id = project_id;
+				return res.send(201, message);
+			});
+		});
+	},
 
-	_getMessages: (client_thread_id, req, res, next) ->
-		{project_id} = req.params
-		if req.query?.before?
-			before = parseInt(req.query.before, 10)
-		else
-			before = null
-		if req.query?.limit?
-			limit = parseInt(req.query.limit, 10)
-		else
-			limit = MessageHttpController.DEFAULT_MESSAGE_LIMIT
-		logger.log {limit, before, project_id, client_thread_id}, "get message request received"
-		ThreadManager.findOrCreateThread project_id, client_thread_id, (error, thread) ->
-			return next(error) if error?
-			thread_object_id = thread._id
-			logger.log {limit, before, project_id, client_thread_id, thread_object_id}, "found or created thread"
-			MessageManager.getMessages thread_object_id, limit, before, (error, messages) ->
-				return next(error) if error?
-				messages = MessageFormatter.formatMessagesForClientSide messages
-				logger.log {project_id, messages}, "got messages"
-				res.send 200, messages
+	_getMessages(client_thread_id, req, res, next) {
+		let before, limit;
+		const {project_id} = req.params;
+		if ((req.query != null ? req.query.before : undefined) != null) {
+			before = parseInt(req.query.before, 10);
+		} else {
+			before = null;
+		}
+		if ((req.query != null ? req.query.limit : undefined) != null) {
+			limit = parseInt(req.query.limit, 10);
+		} else {
+			limit = MessageHttpController.DEFAULT_MESSAGE_LIMIT;
+		}
+		logger.log({limit, before, project_id, client_thread_id}, "get message request received");
+		return ThreadManager.findOrCreateThread(project_id, client_thread_id, function(error, thread) {
+			if (error != null) { return next(error); }
+			const thread_object_id = thread._id;
+			logger.log({limit, before, project_id, client_thread_id, thread_object_id}, "found or created thread");
+			return MessageManager.getMessages(thread_object_id, limit, before, function(error, messages) {
+				if (error != null) { return next(error); }
+				messages = MessageFormatter.formatMessagesForClientSide(messages);
+				logger.log({project_id, messages}, "got messages");
+				return res.send(200, messages);
+			});
+		});
+	}
+});

services/chat/app/coffee/Features/Messages/MessageManager.js

@@ -1,69 +1,98 @@
-mongojs = require "../../mongojs"
-db = mongojs.db
-ObjectId = mongojs.ObjectId
-async = require "async"
-metrics = require 'metrics-sharelatex'
-logger = require 'logger-sharelatex'
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * DS207: Consider shorter variations of null checks
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+let MessageManager;
+const mongojs = require("../../mongojs");
+const { db } = mongojs;
+const { ObjectId } = mongojs;
+const async = require("async");
+const metrics = require('metrics-sharelatex');
+const logger = require('logger-sharelatex');
 
-module.exports = MessageManager =
-	createMessage: (room_id, user_id, content, timestamp, callback = (error, message) ->) ->
-		newMessageOpts = 
-			content: content
-			room_id: room_id
-			user_id: user_id
-			timestamp: timestamp
-		newMessageOpts = @_ensureIdsAreObjectIds(newMessageOpts)
-		db.messages.save newMessageOpts, callback
+module.exports = (MessageManager = {
+	createMessage(room_id, user_id, content, timestamp, callback) {
+		if (callback == null) { callback = function(error, message) {}; }
+		let newMessageOpts = { 
+			content,
+			room_id,
+			user_id,
+			timestamp
+		};
+		newMessageOpts = this._ensureIdsAreObjectIds(newMessageOpts);
+		return db.messages.save(newMessageOpts, callback);
+	},
 
-	getMessages: (room_id, limit, before, callback = (error, messages) ->) ->
-		query =
-			room_id: room_id
-		if before?
-			query.timestamp = { $lt: before }
-		query = @_ensureIdsAreObjectIds(query)
-		cursor = db.messages.find(query).sort({ timestamp: -1 }).limit(limit)
-		cursor.toArray callback
+	getMessages(room_id, limit, before, callback) {
+		if (callback == null) { callback = function(error, messages) {}; }
+		let query =
+			{room_id};
+		if (before != null) {
+			query.timestamp = { $lt: before };
+		}
+		query = this._ensureIdsAreObjectIds(query);
+		const cursor = db.messages.find(query).sort({ timestamp: -1 }).limit(limit);
+		return cursor.toArray(callback);
+	},
 	
-	findAllMessagesInRooms: (room_ids, callback = (error, messages) ->) ->
-		db.messages.find {
+	findAllMessagesInRooms(room_ids, callback) {
+		if (callback == null) { callback = function(error, messages) {}; }
+		return db.messages.find({
 			room_id: { $in: room_ids }
-		}, callback
+		}, callback);
+	},
 
-	deleteAllMessagesInRoom: (room_id, callback = (error) ->) ->
-		db.messages.remove {
-			room_id: room_id
-		}, callback
+	deleteAllMessagesInRoom(room_id, callback) {
+		if (callback == null) { callback = function(error) {}; }
+		return db.messages.remove({
+			room_id
+		}, callback);
+	},
 	
-	updateMessage: (room_id, message_id, content, timestamp, callback = (error, message) ->) ->
-		query = @_ensureIdsAreObjectIds(
-			_id: message_id
-			room_id: room_id
-		)
-		db.messages.update query, {
-			$set:
-				content: content
+	updateMessage(room_id, message_id, content, timestamp, callback) {
+		if (callback == null) { callback = function(error, message) {}; }
+		const query = this._ensureIdsAreObjectIds({
+			_id: message_id,
+			room_id
+		});
+		return db.messages.update(query, {
+			$set: {
+				content,
 				edited_at: timestamp
-		}, (error) ->
-			return callback(error) if error?
-			return callback()
+			}
+		}, function(error) {
+			if (error != null) { return callback(error); }
+			return callback();
+		});
+	},
 
-	deleteMessage: (room_id, message_id, callback = (error) ->) ->
-		query = @_ensureIdsAreObjectIds(
-			_id: message_id
-			room_id: room_id
-		)
-		db.messages.remove query, (error) ->
-			return callback(error) if error?
-			return callback()
+	deleteMessage(room_id, message_id, callback) {
+		if (callback == null) { callback = function(error) {}; }
+		const query = this._ensureIdsAreObjectIds({
+			_id: message_id,
+			room_id
+		});
+		return db.messages.remove(query, function(error) {
+			if (error != null) { return callback(error); }
+			return callback();
+		});
+	},
 
-	_ensureIdsAreObjectIds: (query) ->
-		if query.user_id? and query.user_id not instanceof ObjectId
-			query.user_id = ObjectId(query.user_id)
-		if query.room_id? and query.room_id not instanceof ObjectId
-			query.room_id = ObjectId(query.room_id)
-		if query._id? and query._id not instanceof ObjectId
-			query._id = ObjectId(query._id)
-		return query
+	_ensureIdsAreObjectIds(query) {
+		if ((query.user_id != null) && !(query.user_id instanceof ObjectId)) {
+			query.user_id = ObjectId(query.user_id);
+		}
+		if ((query.room_id != null) && !(query.room_id instanceof ObjectId)) {
+			query.room_id = ObjectId(query.room_id);
+		}
+		if ((query._id != null) && !(query._id instanceof ObjectId)) {
+			query._id = ObjectId(query._id);
+		}
+		return query;
+	}
+});
 
 
 [
@@ -72,5 +101,4 @@ module.exports = MessageManager =
 	'findAllMessagesInRooms',
 	'updateMessage',
 	'deleteMessage'
-].map (method) ->
-	metrics.timeAsyncMethod(MessageManager, method, 'mongo.MessageManager', logger)
+].map(method => metrics.timeAsyncMethod(MessageManager, method, 'mongo.MessageManager', logger));

services/chat/app/coffee/Features/Threads/ThreadManager.js

@@ -1,81 +1,107 @@
-mongojs = require("../../mongojs")
-db = mongojs.db
-ObjectId = mongojs.ObjectId
-logger = require('logger-sharelatex')
-metrics = require('metrics-sharelatex')
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * DS207: Consider shorter variations of null checks
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+let ThreadManager;
+const mongojs = require("../../mongojs");
+const { db } = mongojs;
+const { ObjectId } = mongojs;
+const logger = require('logger-sharelatex');
+const metrics = require('metrics-sharelatex');
 
-module.exports = ThreadManager =
-	GLOBAL_THREAD: "GLOBAL"
+module.exports = (ThreadManager = {
+	GLOBAL_THREAD: "GLOBAL",
 
-	findOrCreateThread: (project_id, thread_id, callback = (error, thread) ->) ->
-		project_id = ObjectId(project_id.toString())
-		if thread_id != ThreadManager.GLOBAL_THREAD
-			thread_id = ObjectId(thread_id.toString())
+	findOrCreateThread(project_id, thread_id, callback) {
+		let query, update;
+		if (callback == null) { callback = function(error, thread) {}; }
+		project_id = ObjectId(project_id.toString());
+		if (thread_id !== ThreadManager.GLOBAL_THREAD) {
+			thread_id = ObjectId(thread_id.toString());
+		}
 
-		if thread_id == ThreadManager.GLOBAL_THREAD
+		if (thread_id === ThreadManager.GLOBAL_THREAD) {
 			query = {
-				project_id: project_id
+				project_id,
 				thread_id: { $exists: false }
-			}
+			};
 			update = {
-				project_id: project_id
-			}
-		else
+				project_id
+			};
+		} else {
 			query = {
-				project_id: project_id
-				thread_id: thread_id
-			}
+				project_id,
+				thread_id
+			};
 			update = {
-				project_id: project_id
-				thread_id: thread_id
-			}
+				project_id,
+				thread_id
+			};
+		}
 		
-		db.rooms.update query, update, { upsert: true }, (error) ->
-			return callback(error) if error?
-			db.rooms.find query, (error, rooms = []) ->
-				return callback(error) if error?
-				return callback null, rooms[0]
+		return db.rooms.update(query, update, { upsert: true }, function(error) {
+			if (error != null) { return callback(error); }
+			return db.rooms.find(query, function(error, rooms) {
+				if (rooms == null) { rooms = []; }
+				if (error != null) { return callback(error); }
+				return callback(null, rooms[0]);
+		});
+	});
+	},
 	
-	findAllThreadRooms: (project_id, callback = (error, rooms) ->) ->
-		db.rooms.find {
-			project_id: ObjectId(project_id.toString())
+	findAllThreadRooms(project_id, callback) {
+		if (callback == null) { callback = function(error, rooms) {}; }
+		return db.rooms.find({
+			project_id: ObjectId(project_id.toString()),
 			thread_id: { $exists: true }
 		}, {
 			thread_id: 1,
 			resolved: 1
-		}, callback
+		}, callback);
+	},
 	
-	resolveThread: (project_id, thread_id, user_id, callback = (error) ->) ->
-		db.rooms.update {
-			project_id: ObjectId(project_id.toString())
+	resolveThread(project_id, thread_id, user_id, callback) {
+		if (callback == null) { callback = function(error) {}; }
+		return db.rooms.update({
+			project_id: ObjectId(project_id.toString()),
 			thread_id: ObjectId(thread_id.toString())
 		}, {
 			$set: {
 				resolved: {
-					user_id: user_id
+					user_id,
 					ts: new Date()
 				}
 			}
-		}, callback
+		}, callback);
+	},
 	
-	reopenThread: (project_id, thread_id, callback = (error) ->) ->
-		db.rooms.update {
-			project_id: ObjectId(project_id.toString())
+	reopenThread(project_id, thread_id, callback) {
+		if (callback == null) { callback = function(error) {}; }
+		return db.rooms.update({
+			project_id: ObjectId(project_id.toString()),
 			thread_id: ObjectId(thread_id.toString())
 		}, {
 			$unset: {
 				resolved: true
 			}
-		}, callback
+		}, callback);
+	},
 
-	deleteThread: (project_id, thread_id, callback = (error, room_id) ->) ->
-		@findOrCreateThread project_id, thread_id, (error, room) ->
-			return callback(error) if error?
-			db.rooms.remove {
+	deleteThread(project_id, thread_id, callback) {
+		if (callback == null) { callback = function(error, room_id) {}; }
+		return this.findOrCreateThread(project_id, thread_id, function(error, room) {
+			if (error != null) { return callback(error); }
+			return db.rooms.remove({
 				_id: room._id
-			}, (error) ->
-				return callback(error) if error?
-				return callback null, room._id
+			}, function(error) {
+				if (error != null) { return callback(error); }
+				return callback(null, room._id);
+			});
+		});
+	}
+});
 
 
 [
@@ -84,5 +110,4 @@ module.exports = ThreadManager =
 	 'resolveThread',
 	 'reopenThread',
 	 'deleteThread',
-].map (method) ->
-	metrics.timeAsyncMethod(ThreadManager, method, 'mongo.ThreadManager', logger)
+].map(method => metrics.timeAsyncMethod(ThreadManager, method, 'mongo.ThreadManager', logger));

services/chat/app/coffee/mongojs.js

@@ -1,6 +1,7 @@
-Settings = require("settings-sharelatex")
-mongojs = require "mongojs"
-db = mongojs(Settings.mongo.url, ["rooms", "messages"])
-module.exports =
-	db: db
+const Settings = require("settings-sharelatex");
+const mongojs = require("mongojs");
+const db = mongojs(Settings.mongo.url, ["rooms", "messages"]);
+module.exports = {
+	db,
 	ObjectId: mongojs.ObjectId
+};

services/chat/app/coffee/router.js

@@ -1,39 +1,50 @@
-MessageHttpController = require('./Features/Messages/MessageHttpController')
-{ObjectId} = require "./mongojs"
-
-module.exports = Router =
-	route: (app) ->
-		app.param 'project_id', (req, res, next, project_id) ->
-			if ObjectId.isValid(project_id)
-				next()
-			else
-				res.send 400, "Invalid project_id"
-
-		app.param 'thread_id', (req, res, next, thread_id) ->
-			if ObjectId.isValid(thread_id)
-				next()
-			else
-				res.send 400, "Invalid thread_id"
-
-		# These are for backwards compatibility
-		app.get  "/room/:project_id/messages", MessageHttpController.getGlobalMessages
-		app.post "/room/:project_id/messages", MessageHttpController.sendGlobalMessage
-
-		app.get  "/project/:project_id/messages", MessageHttpController.getGlobalMessages
-		app.post "/project/:project_id/messages", MessageHttpController.sendGlobalMessage
-
-		app.post "/project/:project_id/thread/:thread_id/messages", MessageHttpController.sendThreadMessage
-		app.get  "/project/:project_id/threads", MessageHttpController.getAllThreads
-
-		app.post "/project/:project_id/thread/:thread_id/messages/:message_id/edit", MessageHttpController.editMessage
-		app.del  "/project/:project_id/thread/:thread_id/messages/:message_id", MessageHttpController.deleteMessage
-
-		app.post "/project/:project_id/thread/:thread_id/resolve", MessageHttpController.resolveThread
-		app.post "/project/:project_id/thread/:thread_id/reopen", MessageHttpController.reopenThread
-		app.del  "/project/:project_id/thread/:thread_id", MessageHttpController.deleteThread
-
-		app.get "/status", (req, res, next) ->
-			res.send("chat is alive")
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+let Router;
+const MessageHttpController = require('./Features/Messages/MessageHttpController');
+const {ObjectId} = require("./mongojs");
+
+module.exports = (Router = {
+	route(app) {
+		app.param('project_id', function(req, res, next, project_id) {
+			if (ObjectId.isValid(project_id)) {
+				return next();
+			} else {
+				return res.send(400, "Invalid project_id");
+			}
+		});
+
+		app.param('thread_id', function(req, res, next, thread_id) {
+			if (ObjectId.isValid(thread_id)) {
+				return next();
+			} else {
+				return res.send(400, "Invalid thread_id");
+			}
+		});
+
+		// These are for backwards compatibility
+		app.get("/room/:project_id/messages", MessageHttpController.getGlobalMessages);
+		app.post("/room/:project_id/messages", MessageHttpController.sendGlobalMessage);
+
+		app.get("/project/:project_id/messages", MessageHttpController.getGlobalMessages);
+		app.post("/project/:project_id/messages", MessageHttpController.sendGlobalMessage);
+
+		app.post("/project/:project_id/thread/:thread_id/messages", MessageHttpController.sendThreadMessage);
+		app.get("/project/:project_id/threads", MessageHttpController.getAllThreads);
+
+		app.post("/project/:project_id/thread/:thread_id/messages/:message_id/edit", MessageHttpController.editMessage);
+		app.del("/project/:project_id/thread/:thread_id/messages/:message_id", MessageHttpController.deleteMessage);
+
+		app.post("/project/:project_id/thread/:thread_id/resolve", MessageHttpController.resolveThread);
+		app.post("/project/:project_id/thread/:thread_id/reopen", MessageHttpController.reopenThread);
+		app.del("/project/:project_id/thread/:thread_id", MessageHttpController.deleteThread);
+
+		return app.get("/status", (req, res, next) => res.send("chat is alive"));
+	}
+});
 
 
 			

services/chat/app/coffee/server.js

@@ -1,39 +1,48 @@
-logger = require 'logger-sharelatex'
-logger.initialize("chat-sharelatex")
-metrics = require("metrics-sharelatex")
-metrics.initialize("chat")
-Path = require("path")
-express = require("express")
-app = express()
-server = require("http").createServer(app)
-Router = require "./router"
+/*
+ * decaffeinate suggestions:
+ * DS102: Remove unnecessary code created because of implicit returns
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+const logger = require('logger-sharelatex');
+logger.initialize("chat-sharelatex");
+const metrics = require("metrics-sharelatex");
+metrics.initialize("chat");
+const Path = require("path");
+const express = require("express");
+const app = express();
+const server = require("http").createServer(app);
+const Router = require("./router");
 
-app.use express.bodyParser()
-app.use metrics.http.monitor(logger)
+app.use(express.bodyParser());
+app.use(metrics.http.monitor(logger));
 
-if (app.get 'env') == 'development'
-	console.log "Development Enviroment"
-	app.use express.errorHandler({ dumpExceptions: true, showStack: true })
+if ((app.get('env')) === 'development') {
+	console.log("Development Enviroment");
+	app.use(express.errorHandler({ dumpExceptions: true, showStack: true }));
+}
 
-if (app.get 'env') == 'production'
-	console.log "Production Enviroment"
-	app.use express.logger()
-	app.use express.errorHandler()
+if ((app.get('env')) === 'production') {
+	console.log("Production Enviroment");
+	app.use(express.logger());
+	app.use(express.errorHandler());
+}
 	
-profiler = require "v8-profiler"
-app.get "/profile", (req, res) ->
-	time = parseInt(req.query.time || "1000")
-	profiler.startProfiling("test")
-	setTimeout () ->
-		profile = profiler.stopProfiling("test")
-		res.json(profile)
-	, time
+const profiler = require("v8-profiler");
+app.get("/profile", function(req, res) {
+	const time = parseInt(req.query.time || "1000");
+	profiler.startProfiling("test");
+	return setTimeout(function() {
+		const profile = profiler.stopProfiling("test");
+		return res.json(profile);
+	}
+	, time);
+});
 
-Router.route(app)
+Router.route(app);
 
 module.exports = {
-	server: server
-	app: app
-}
+	server,
+	app
+};