Added message sending

lib/Client/Client.js

@@ -23,9 +23,7 @@ var Client = (function (_EventEmitter) {
 		this.internal = new InternalClient(this);
 	}
 
-	/*
- 	def login
- */
+	// def login
 
 	Client.prototype.login = function login(email, password) {
 		var cb = arguments.length <= 2 || arguments[2] === undefined ? function (err, token) {} : arguments[2];
@@ -43,9 +41,104 @@ var Client = (function (_EventEmitter) {
 		});
 	};
 
-	/*
- 	def logout
- */
+	// def logout
+
+	Client.prototype.logout = function logout() {
+		var cb = arguments.length <= 0 || arguments[0] === undefined ? function (err) {} : arguments[0];
+
+		var self = this;
+		return new Promise(function (resolve, reject) {
+
+			self.internal.logout().then(function () {
+				cb();
+				resolve();
+			})["catch"](function (e) {
+				cb(e);
+				reject(e);
+			});
+		});
+	};
+
+	Client.prototype.sendMessage = function sendMessage(where, content) {
+		var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
+		var callback = arguments.length <= 3 || arguments[3] === undefined ? function (e, m) {} : arguments[3];
+
+		var self = this;
+		return new Promise(function (resolve, reject) {
+
+			if (typeof options === "function") {
+				// options is the callback
+				callback = options;
+			}
+
+			self.internal.sendMessage(where, content, options).then(function (m) {
+				callback(null, m);
+				resolve(m);
+			})["catch"](function (e) {
+				callback(e);
+				reject(e);
+			});
+		});
+	};
+
+	Client.prototype.sendTTSMessage = function sendTTSMessage(where, content) {
+		var callback = arguments.length <= 2 || arguments[2] === undefined ? function (e, m) {} : arguments[2];
+
+		var self = this;
+		return new Promise(function (resolve, reject) {
+			self.sendMessage(where, content, { tts: true }).then(function (m) {
+				callback(null, m);
+				resolve(m);
+			})["catch"](function (e) {
+				callback(e);
+				reject(e);
+			});
+		});
+	};
+
+	Client.prototype.reply = function reply(where, content) {
+		var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
+		var callback = arguments.length <= 3 || arguments[3] === undefined ? function (e, m) {} : arguments[3];
+
+		var self = this;
+		return new Promise(function (resolve, reject) {
+
+			if (typeof options === "function") {
+				// options is the callback
+				callback = options;
+			}
+
+			var msg = self.internal.resolver.resolveMessage(where);
+			if (msg) {
+				content = msg.author + ", " + content;
+				self.internal.sendMessage(msg, content, options).then(function (m) {
+					callback(null, m);
+					resolve(m);
+				})["catch"](function (e) {
+					callback(e);
+					reject(e);
+				});
+			} else {
+				var err = new Error("Destination not resolvable to a message!");
+				callback(err);
+				reject(err);
+			}
+		});
+	};
+
+	Client.prototype.replyTTS = function replyTTS(where, content) {
+		var callback = arguments.length <= 2 || arguments[2] === undefined ? function () {} : arguments[2];
+
+		return new Promise(function (resolve, reject) {
+			self.reply(where, content, { tts: true }).then(function (m) {
+				callback(null, m);
+				resolve(m);
+			})["catch"](function (e) {
+				callback(e);
+				reject(e);
+			});
+		});
+	};
 
 	return Client;
 })(EventEmitter);

lib/Client/InternalClient.js

@@ -12,6 +12,7 @@ var Constants = require("../Constants.js"),
     PacketType = Constants.PacketType;
 
 var Cache = require("../Util/Cache.js");
+var Resolver = require("./Resolver/Resolver.js");
 
 var User = require("../Structures/User.js"),
     Channel = require("../Structures/Channel.js"),
@@ -40,6 +41,7 @@ var InternalClient = (function () {
 		this.channels = new Cache();
 		this.servers = new Cache();
 		this.private_channels = new Cache();
+		this.resolver = new Resolver(this);
 	}
 
 	// def login
@@ -114,6 +116,29 @@ var InternalClient = (function () {
 		});
 	};
 
+	// def startPM
+
+	InternalClient.prototype.startPM = function startPM(resUser) {
+		var self = this;
+		return new Promise(function (resolve, reject) {
+			var user = self.resolver.resolveUser(resUser);
+
+			if (user) {
+
+				// start the PM
+				request.post("" + Endpoints.USER_CHANNELS(user.id)).set("authorization", self.token).end(function (err, res) {
+					if (err) {
+						reject(new Error(err.response.text));
+					} else {
+						resolve(self.private_channels.add(new PMChannel(res.body, self.client)));
+					}
+				});
+			} else {
+				reject(new Error("Unable to resolve resUser to a User"));
+			}
+		});
+	};
+
 	// def getGateway
 
 	InternalClient.prototype.getGateway = function getGateway() {
@@ -126,6 +151,39 @@ var InternalClient = (function () {
 		});
 	};
 
+	// def sendMessage
+
+	InternalClient.prototype.sendMessage = function sendMessage(where, _content) {
+		var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
+
+		var self = this;
+		return new Promise(function (resolve, reject) {
+
+			self.resolver.resolveChannel(where).then(next)["catch"](function (e) {
+				return reject(new Error("Error resolving destination"));
+			});
+
+			function next(destination) {
+				//var destination;
+				var content = self.resolver.resolveString(_content);
+				var mentions = self.resolver.resolveMentions(content);
+
+				request.post(Endpoints.CHANNEL_MESSAGES(destination.id)).set("authorization", self.token).send({
+					content: content,
+					mentions: mentions,
+					tts: options.tts
+				}).end(function (err, res) {
+					if (err) {
+						reject(new Error(err.response.text));
+					} else {
+
+						resolve(destination.messages.add(new Message(res.body, destination, self.client)));
+					}
+				});
+			}
+		});
+	};
+
 	InternalClient.prototype.sendWS = function sendWS(object) {
 		this.websocket.send(JSON.stringify(object));
 	};
@@ -207,7 +265,8 @@ var InternalClient = (function () {
 					// format: https://discordapi.readthedocs.org/en/latest/reference/channels/messages.html#message-format
 					var channel = self.channels.get("id", data.channel_id);
 					if (channel) {
-						channel.messages.add(new Message(data, channel, client));
+						var msg = channel.messages.add(new Message(data, channel, client));
+						client.emit("message", msg);
 					} else {
 						client.emit("warn", "message created but channel is not cached");
 					}

lib/Client/Resolver/Resolver.js

@@ -2,6 +2,149 @@
 
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-var Resolver = function Resolver() {
-	_classCallCheck(this, Resolver);
-};
+var User = require("../../Structures/User.js"),
+    Channel = require("../../Structures/Channel.js"),
+    TextChannel = require("../../Structures/TextChannel.js"),
+    VoiceChannel = require("../../Structures/VoiceChannel.js"),
+    ServerChannel = require("../../Structures/ServerChannel.js"),
+    PMChannel = require("../../Structures/PMChannel.js"),
+    Server = require("../../Structures/Server.js"),
+    Message = require("../../Structures/Message.js");
+
+var Resolver = (function () {
+	function Resolver(client) {
+		_classCallCheck(this, Resolver);
+
+		this.client = client;
+	}
+
+	Resolver.prototype.resolveMentions = function resolveMentions(resource) {
+		// resource is a string
+		var _mentions = [];
+		for (var _iterator = resource.match(/<@[^>]*>/g) || [], _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+			var _ref;
+
+			if (_isArray) {
+				if (_i >= _iterator.length) break;
+				_ref = _iterator[_i++];
+			} else {
+				_i = _iterator.next();
+				if (_i.done) break;
+				_ref = _i.value;
+			}
+
+			var mention = _ref;
+
+			_mentions.push(mention.substring(2, mention.length - 1));
+		}
+		return _mentions;
+	};
+
+	Resolver.prototype.resolveString = function resolveString(resource) {
+
+		// accepts Array, Channel, Server, User, Message, String and anything
+		// toString()-able
+
+		var final = resource;
+		if (resource instanceof Array) {
+			final = resource.join("\n");
+		}
+
+		return final.toString();
+	};
+
+	Resolver.prototype.resolveUser = function resolveUser(resource) {
+		/*
+  	accepts a Message, Channel, Server, String ID, User, PMChannel
+  */
+		var found = null;
+		if (resource instanceof Message) {
+			found = resource.author;
+		} else if (resource instanceof TextChannel) {
+			var lmsg = resource.lastMessage;
+			if (lmsg) {
+				found = lmsg.author;
+			}
+		} else if (resource instanceof Server) {
+			found = resource.owner;
+		} else if (resource instanceof PMChannel) {
+			found = resource.recipient;
+		} else if (resource instanceof String || typeof resource === "string") {
+			found = this.client.internal.users.get("id", resource);
+		}
+
+		return found;
+	};
+
+	Resolver.prototype.resolveMessage = function resolveMessage(resource) {
+		// accepts a Message, PMChannel & TextChannel
+		var found = null;
+
+		if (resource instanceof TextChannel || resource instanceof PMChannel) {
+			found = resource.lastMessage;
+		} else if (resource instanceof Message) {
+			found = resource;
+		}
+
+		return found;
+	};
+
+	Resolver.prototype.resolveChannel = function resolveChannel(resource) {
+		/*
+  	accepts a Message, Channel, Server, String ID, User
+   */
+		var self = this;
+
+		return new Promise(function (resolve, reject) {
+			var found = null;
+			if (resource instanceof Message) {
+				found = resource.channel;
+			} else if (resource instanceof Channel) {
+				found = resource;
+			} else if (resource instanceof Server) {
+				found = resource.channels.get("id", resource.id);
+			} else if (resource instanceof String || typeof resource === "string") {
+				found = self.client.internal.channels.get("id", resource);
+			} else if (resource instanceof User) {
+				// see if a PM exists
+				var chatFound = false;
+				for (var _iterator2 = self.client.internal.private_channels, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+					var _ref2;
+
+					if (_isArray2) {
+						if (_i2 >= _iterator2.length) break;
+						_ref2 = _iterator2[_i2++];
+					} else {
+						_i2 = _iterator2.next();
+						if (_i2.done) break;
+						_ref2 = _i2.value;
+					}
+
+					var pmchat = _ref2;
+
+					if (pmchat.recipient.equals(resource)) {
+						chatFound = pmchat;
+						break;
+					}
+				}
+				if (chatFound) {
+					// a PM already exists!
+					found = chatFound;
+				} else {
+					// PM does not exist :\
+					self.client.internal.startPM(resource).then(function (pmchannel) {
+						return resolve(pmchannel);
+					})["catch"](function (e) {
+						return reject(e);
+					});
+					return;
+				}
+			}
+			if (found) resolve(found);else reject();
+		});
+	};
+
+	return Resolver;
+})();
+
+module.exports = Resolver;