Added message sending

src/Client/Client.js

@@ -14,12 +14,10 @@ class Client extends EventEmitter{
 		this.internal = new InternalClient(this);
 	}
 	
-	/*
-		def login
-	*/
+	// def login
 	login(email, password, cb=function(err, token){}){
 		var self = this;
-		return new Promise(function(resolve, reject){
+		return new Promise((resolve, reject) => {
 			
 			self.internal.login(email, password)
 				.then((token)=>{
@@ -34,10 +32,101 @@ class Client extends EventEmitter{
 		});
 	}
 	
-	/*
-		def logout
-	*/
+	// def logout
+	logout(cb=function(err){}){
+		var self = this;
+		return new Promise((resolve, reject) => {
+			
+			self.internal.logout()
+				.then(() => {
+					cb();
+					resolve();
+				})
+				.catch((e) => {
+					cb(e);
+					reject(e);
+				})
+			
+		})
+	}
 	
+	sendMessage(where, content, options={}, callback=function(e, m){}){
+		var self = this;
+		return new Promise((resolve, reject) => {
+			
+			if(typeof options === "function"){
+				// options is the callback
+				callback = options;
+			}
+			
+			self.internal.sendMessage(where, content, options)
+				.then(m => {
+					callback(null, m);
+					resolve(m);
+				}).catch(e => {
+					callback(e);
+					reject(e);
+				});
+			
+		});
+	}
+	
+	sendTTSMessage(where, content, callback=function(e, m){}){
+		var self = this;
+		return new Promise((resolve, reject) => {
+			self.sendMessage(where, content, {tts:true})
+				.then(m => {
+					callback(null, m);
+					resolve(m);
+				}).catch(e => {
+					callback(e);
+					reject(e);
+				});
+			
+		});
+	}
+	
+	reply(where, content, options={}, callback=function(e,m){}){
+		var self = this;
+		return new Promise((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(m => {
+					callback(null, m);
+					resolve(m);
+				}).catch(e => {
+					callback(e);
+					reject(e);
+				});
+			}else{
+				var err = new Error("Destination not resolvable to a message!");
+				callback(err);
+				reject(err);
+			}
+			
+		});
+	}
+	
+	replyTTS(where, content, callback=function(){}){
+		return new Promise((resolve, reject)=>{
+			self.reply(where, content, {tts:true})
+				.then(m => {
+					callback(null, m);
+					resolve(m);
+				}).catch(e => {
+					callback(e);
+					reject(e);
+				});
+		});
+	}
 }
 
 module.exports = Client;

src/Client/InternalClient.js

@@ -8,7 +8,7 @@ var ConnectionState = require("./ConnectionState.js");
 var Constants = require("../Constants.js"),
 	Endpoints = Constants.Endpoints,
 	PacketType = Constants.PacketType;
-	
+
 var Cache = require("../Util/Cache.js");
 var Resolver = require("./Resolver/Resolver.js");
 
@@ -88,21 +88,21 @@ class InternalClient {
 	// def logout
 	logout() {
 		var self = this;
-		return new Promise((resolve, reject)=>{
-			
-			if(self.state === ConnectionState.DISCONNECTED || self.state === ConnectionState.IDLE){
+		return new Promise((resolve, reject) => {
+
+			if (self.state === ConnectionState.DISCONNECTED || self.state === ConnectionState.IDLE) {
 				reject(new Error("Client is not logged in!"));
 				return;
 			}
-			
+
 			request
 				.post(Endpoints.LOGOUT)
 				.set("authorization", self.token)
 				.end((err, res) => {
-					if(err){
+					if (err) {
 						reject(new Error(err.response.text));
-					}else{
-						if(this.websocket){
+					} else {
+						if (this.websocket) {
 							this.websocket.close();
 							this.websocket = null;
 						}
@@ -113,34 +113,34 @@ class InternalClient {
 						resolve();
 					}
 				});
-			
+
 		});
 	}
 	
 	// def startPM
-	startPM(resUser){
+	startPM(resUser) {
 		var self = this;
 		return new Promise((resolve, reject) => {
 			var user = self.resolver.resolveUser(resUser);
-		
-			if(user){
+
+			if (user) {
 				
 				// start the PM
 				request
-					.post(`${Endpoints.USER_CHANNELS(user.id)}`)
+					.post(`${Endpoints.USER_CHANNELS(user.id) }`)
 					.set("authorization", self.token)
 					.end((err, res) => {
-						if(err){
+						if (err) {
 							reject(new Error(err.response.text));
-						}else{
+						} else {
 							resolve(self.private_channels.add(new PMChannel(res.body, self.client)));
 						}
 					});
-				
-			}else{
+
+			} else {
 				reject(new Error("Unable to resolve resUser to a User"));
 			}
-			
+
 		});
 	}
 
@@ -161,6 +161,47 @@ class InternalClient {
 
 		});
 	}
+	
+	// def sendMessage
+	sendMessage(where, _content, options={}) {
+		var self = this;
+		return new Promise((resolve, reject) => {
+
+			self.resolver.resolveChannel(where)
+				.then(next)
+				.catch(e => 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((err, res) => {
+						if (err) {
+							reject(new Error(err.response.text));
+						} else {
+
+							resolve(
+								destination.messages.add(
+									new Message(res.body, destination, self.client)
+									)
+								);
+
+						}
+					});
+
+			}
+
+		});
+	}
 
 	sendWS(object) {
 		this.websocket.send(JSON.stringify(object));
@@ -203,7 +244,7 @@ class InternalClient {
 		this.websocket.onmessage = (e) => {
 
 			if (e.type === "Binary") {
-				if(!zlib) zlib = require("zlib");
+				if (!zlib) zlib = require("zlib");
 				e.data = zlib.inflateSync(e.data).toString();
 			}
 
@@ -230,20 +271,21 @@ class InternalClient {
 						self.private_channels.add(new PMChannel(pm, client));
 					});
 					self.state = ConnectionState.READY;
-					
-					setInterval( ()=> self.sendWS({op : 1, d : Date.now()}), data.heartbeat_interval);
-					
+
+					setInterval(() => self.sendWS({ op: 1, d: Date.now() }), data.heartbeat_interval);
+
 					client.emit("ready");
 					client.emit("debug", `ready packet took ${Date.now() - startTime}ms to process`);
 					client.emit("debug", `ready with ${self.servers.length} servers, ${self.channels.length} channels and ${self.users.length} users cached.`);
 					break;
-				
+
 				case PacketType.MESSAGE_CREATE:
 					// 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) );	
-					}else{
+					if (channel) {
+						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");
 					}
 					break;

src/Client/Resolver/Resolver.js

@@ -4,6 +4,7 @@ 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");
@@ -12,26 +13,61 @@ class Resolver {
 	constructor(client) {
 		this.client = client;
 	}
-	
+
+	resolveMentions(resource) {
+		// resource is a string
+		var _mentions = [];
+		for (var mention of (resource.match(/<@[^>]*>/g) || [])) {
+			_mentions.push(mention.substring(2, mention.length - 1));
+		}
+		return _mentions;
+	}
+
+	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();
+	}
+
 	resolveUser(resource) {
 		/*
 			accepts a Message, Channel, Server, String ID, User, PMChannel
 		*/
 		var found = null;
-		if(resource instanceof Message){
+		if (resource instanceof Message) {
 			found = resource.author;
-		}else if(resource instanceof TextChannel){
+		} else if (resource instanceof TextChannel) {
 			var lmsg = resource.lastMessage;
-			if(lmsg){
+			if (lmsg) {
 				found = lmsg.author;
 			}
-		}else if(resource instanceof Server){
+		} else if (resource instanceof Server) {
 			found = resource.owner;
-		}else if(resource instanceof PMChannel){
+		} else if (resource instanceof PMChannel) {
 			found = resource.recipient;
-		}else if(resource instanceof String || typeof resource === "string"){
+		} else if (resource instanceof String || typeof resource === "string") {
 			found = this.client.internal.users.get("id", resource);
 		}
+
+		return found;
+	}
+	
+	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;
 	}
@@ -55,24 +91,24 @@ class Resolver {
 			} else if (resource instanceof User) {
 				// see if a PM exists
 				var chatFound = false;
-				for(var pmchat of self.client.internal.private_channels){
-					if(pmchat.recipient.equals(resource)){
+				for (var pmchat of self.client.internal.private_channels) {
+					if (pmchat.recipient.equals(resource)) {
 						chatFound = pmchat;
 						break;
 					}
 				}
-				if(chatFound){
+				if (chatFound) {
 					// a PM already exists!
 					found = chatFound;
-				}else{
+				} else {
 					// PM does not exist :\
 					self.client.internal.startPM(resource)
-						.then( pmchannel => resolve(pmchannel) )
-						.catch( e => reject(e) );
+						.then(pmchannel => resolve(pmchannel))
+						.catch(e => reject(e));
 					return;
 				}
 			}
-			if(found)
+			if (found)
 				resolve(found);
 			else
 				reject();

src/Structures/Message.js

@@ -26,10 +26,13 @@ class Message{
 			// this is .add and not .get because it allows the bot to cache
 			// users from messages from logs who may have left the server and were
 			// not previously cached.
-			console.log(mention);
 			this.mentions.add(client.internal.users.add(new User(mention, client)));
 		});
 	}
+	
+	toString(){
+		return this.content;
+	}
 }
 
 module.exports = Message;

src/Structures/PMChannel.js

@@ -18,6 +18,10 @@ class PMChannel extends Equality{
 	get lastMessage(){
 		return this.messages.get("id", this.lastMessageID);
 	}
+	
+	toString(){
+		return this.recipient.toString();
+	}
 }
 
 module.exports = PMChannel;

src/Structures/ServerChannel.js

@@ -7,12 +7,17 @@ var PermissionOverwrite = require("./PermissionOverwrite.js");
 class ServerChannel extends Channel{
 	constructor(data, client){
 		super(data, client);
+		this.name = data.name;
 		this.type = data.type;
 		this.permissionOverwrites = new Cache();
 		data.permission_overwrites.forEach((permission) => {
 			this.permissionOverwrites.add( new PermissionOverwrite(permission) );
 		});
 	}
+	
+	toString(){
+		return this.name;
+	}
 }
 
 module.exports = ServerChannel;

src/index.js

@@ -4,4 +4,10 @@ module.exports = {
 
 var a = new module.exports.Client();
 a.on("debug", (m) => console.log("[debug]",m));
+
+a.on("message", m => {
+	if(m.content === "$$$")
+		a.reply(m, "hi man!").catch(e => console.log(e.stack));
+});
+
 a.login(process.env["discordEmail"], process.env["discordPass"]).catch((e)=>console.log(e));