initial

src/client/websocket/WebSocketManager.js

@@ -0,0 +1,79 @@
+'use strict';
+
+const WebSocket = require('ws');
+const Constants = require('../../util/Constants');
+const zlib = require('zlib');
+const PacketManager = require('./packets/WebSocketPacketManager');
+
+class WebSocketManager {
+
+	constructor(client) {
+		this.client = client;
+		this.ws = null;
+		this.packetManager = new PacketManager(this);
+		this.emittedReady = false;
+	}
+
+	connect(gateway) {
+		gateway += `/?v=${this.client.options.protocol_version}`;
+		this.ws = new WebSocket(gateway);
+		this.ws.onopen = () => this.EventOpen();
+		this.ws.onclose = () => this.EventClose();
+		this.ws.onmessage = (e) => this.EventMessage(e);
+		this.ws.onerror = (e) => this.EventError(e);
+	}
+
+	send(data) {
+		this.ws.send(JSON.stringify(data));
+	}
+
+	EventOpen() {
+		let payload = this.client.options.ws;
+		payload.token = this.client.store.token;
+
+		this.send({
+			op: Constants.OPCodes.IDENTIFY,
+			d: payload,
+		});
+	}
+
+	EventClose() {
+
+	}
+
+	EventMessage(event) {
+		let packet;
+		try {
+			if (event.binary) {
+				event.data = zlib.inflateSync(event.data).toString();
+			}
+
+			packet = JSON.parse(event.data);
+		} catch (e) {
+			return this.EventError(Constants.Errors.BAD_WS_MESSAGE);
+		}
+
+		this.packetManager.handle(packet);
+	}
+
+	EventError(e) {
+
+	}
+
+	checkIfReady() {
+		if (!this.emittedReady) {
+			let unavailableCount = 0;
+
+			for (let guildID in this.client.store.data.guilds) {
+				unavailableCount += this.client.store.data.guilds[guildID].available ? 0 : 1;
+			}
+
+			if (unavailableCount === 0) {
+				this.client.emit(Constants.Events.READY);
+				this.emittedReady = true;
+			}
+		}
+	}
+}
+
+module.exports = WebSocketManager;

src/client/websocket/packets/WebSocketPacketManager.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const Constants = require('../../../util/Constants');
+
+class WebSocketPacketManager {
+
+	constructor(websocketManager) {
+		this.ws = websocketManager;
+		this.handlers = {};
+
+		this.register(Constants.WSEvents.READY, 'Ready');
+		this.register(Constants.WSEvents.GUILD_CREATE, 'GuildCreate');
+		this.register(Constants.WSEvents.GUILD_DELETE, 'GuildDelete');
+		this.register(Constants.WSEvents.GUILD_UPDATE, 'GuildUpdate');
+		this.register(Constants.WSEvents.GUILD_BAN_ADD, 'GuildBanAdd');
+		this.register(Constants.WSEvents.GUILD_BAN_REMOVE, 'GuildBanRemove');
+		this.register(Constants.WSEvents.GUILD_MEMBER_ADD, 'GuildMemberAdd');
+		this.register(Constants.WSEvents.GUILD_MEMBER_REMOVE, 'GuildMemberRemove');
+		this.register(Constants.WSEvents.GUILD_MEMBER_UPDATE, 'GuildMemberUpdate');
+		this.register(Constants.WSEvents.CHANNEL_CREATE, 'ChannelCreate');
+		this.register(Constants.WSEvents.CHANNEL_DELETE, 'ChannelDelete');
+		this.register(Constants.WSEvents.CHANNEL_UPDATE, 'ChannelUpdate');
+	}
+
+	get client() {
+		return this.ws.client;
+	}
+
+	register(event, handle) {
+		let Handler = require(`./handlers/${handle}`);
+		this.handlers[event] = new Handler(this);
+	}
+
+	handle(packet) {
+		if (this.handlers[packet.t]) {
+			return this.handlers[packet.t].handle(packet);
+		}
+
+		return false;
+	}
+
+}
+
+module.exports = WebSocketPacketManager;

src/client/websocket/packets/handlers/AbstractHandler.js

@@ -0,0 +1,14 @@
+'use strict';
+
+class AbstractHandler {
+
+	constructor(packetManager) {
+		this.packetManager = packetManager;
+	}
+
+	handle(packet) {
+
+	}
+}
+
+module.exports = AbstractHandler;

src/client/websocket/packets/handlers/ChannelCreate.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const AbstractHandler = require('./AbstractHandler');
+const Structure = name => require(`../../../../structures/${name}`);
+
+const ClientUser = Structure('ClientUser');
+const Guild = Structure('Guild');
+const DMChannel = Structure('DMChannel');
+
+const Constants = require('../../../../util/Constants');
+
+class ChannelCreateHandler extends AbstractHandler {
+
+	constructor(packetManager) {
+		super(packetManager);
+	}
+
+	handle(packet) {
+		let data = packet.d;
+		let client = this.packetManager.client;
+
+		let channel = client.store.NewChannel(data);
+
+	}
+
+};
+
+module.exports = ChannelCreateHandler;

src/client/websocket/packets/handlers/ChannelDelete.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const AbstractHandler = require('./AbstractHandler');
+const Structure = name => require(`../../../../structures/${name}`);
+
+const ClientUser = Structure('ClientUser');
+const Guild = Structure('Guild');
+const ServerChannel = Structure('ServerChannel');
+
+const Constants = require('../../../../util/Constants');
+
+class ChannelDeleteHandler extends AbstractHandler {
+
+	constructor(packetManager) {
+		super(packetManager);
+	}
+
+	handle(packet) {
+		let data = packet.d;
+		let client = this.packetManager.client;
+
+		let channel = client.store.get('channels', data.id);
+
+		if (channel) {
+			client.store.KillChannel(channel);
+		}
+	}
+
+};
+
+module.exports = ChannelDeleteHandler;

src/client/websocket/packets/handlers/ChannelUpdate.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const AbstractHandler = require('./AbstractHandler');
+const Structure = name => require(`../../../../structures/${name}`);
+
+const ClientUser = Structure('ClientUser');
+const Guild = Structure('Guild');
+const ServerChannel = Structure('ServerChannel');
+
+const Constants = require('../../../../util/Constants');
+const CloneObject = require('../../../../util/CloneObject');
+
+class ChannelUpdateHandler extends AbstractHandler {
+
+	constructor(packetManager) {
+		super(packetManager);
+	}
+
+	handle(packet) {
+		let data = packet.d;
+		let client = this.packetManager.client;
+
+		let channel = client.store.get('channels', data.id);
+
+		if (channel) {
+			client.store.UpdateChannel(channel, data);
+		}
+
+	}
+
+};
+
+module.exports = ChannelUpdateHandler;

src/client/websocket/packets/handlers/GuildBanAdd.js

@@ -0,0 +1,33 @@
+'use strict';
+
+// ##untested handler##
+
+const AbstractHandler = require('./AbstractHandler');
+const Structure = name => require(`../../../../structures/${name}`);
+
+const ClientUser = Structure('ClientUser');
+const Guild = Structure('Guild');
+
+const Constants = require('../../../../util/Constants');
+
+class GuildBanAddHandler extends AbstractHandler {
+
+	constructor(packetManager) {
+		super(packetManager);
+	}
+
+	handle(packet) {
+		let data = packet.d;
+		let client = this.packetManager.client;
+
+		let guild = client.store.get('guilds', data.guild_id);
+		let user = client.store.get('users', data.user.id);
+
+		if (guild && user) {
+			client.emit(Constants.Events.GUILD_BAN_ADD, guild, user);
+		}
+	}
+
+};
+
+module.exports = GuildBanAddHandler;

src/client/websocket/packets/handlers/GuildBanRemove.js

@@ -0,0 +1,33 @@
+'use strict';
+
+// ##untested handler##
+
+const AbstractHandler = require('./AbstractHandler');
+const Structure = name => require(`../../../../structures/${name}`);
+
+const ClientUser = Structure('ClientUser');
+const Guild = Structure('Guild');
+
+const Constants = require('../../../../util/Constants');
+
+class GuildBanRemoveHandler extends AbstractHandler {
+
+	constructor(packetManager) {
+		super(packetManager);
+	}
+
+	handle(packet) {
+		let data = packet.d;
+		let client = this.packetManager.client;
+
+		let guild = client.store.get('guilds', data.guild_id);
+		let user = client.store.get('users', data.user.id);
+
+		if (guild && user) {
+			client.emit(Constants.Events.GUILD_BAN_REMOVE, guild, user);
+		}
+	}
+
+};
+
+module.exports = GuildBanRemoveHandler;

src/client/websocket/packets/handlers/GuildCreate.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const AbstractHandler = require('./AbstractHandler');
+const Structure = name => require(`../../../../structures/${name}`);
+
+const ClientUser = Structure('ClientUser');
+const Guild = Structure('Guild');
+
+const Constants = require('../../../../util/Constants');
+
+class GuildCreateHandler extends AbstractHandler {
+
+	constructor(packetManager) {
+		super(packetManager);
+	}
+
+	handle(packet) {
+		let data = packet.d;
+		let client = this.packetManager.client;
+
+		let guild = client.store.get('guilds', data.id);
+
+		if (guild) {
+			if (!guild.available && !data.unavailable) {
+				// a newly available guild
+				guild.setup(data);
+				this.packetManager.ws.checkIfReady();
+			}
+		} else {
+			// a new guild
+			client.store.NewGuild(data);
+		}
+
+	}
+
+};
+
+module.exports = GuildCreateHandler;

src/client/websocket/packets/handlers/GuildDelete.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const AbstractHandler = require('./AbstractHandler');
+const Structure = name => require(`../../../../structures/${name}`);
+
+const ClientUser = Structure('ClientUser');
+const Guild = Structure('Guild');
+
+const Constants = require('../../../../util/Constants');
+
+class GuildDeleteHandler extends AbstractHandler {
+
+	constructor(packetManager) {
+		super(packetManager);
+	}
+
+	handle(packet) {
+		let data = packet.d;
+		let client = this.packetManager.client;
+
+		let guild = client.store.get('guilds', data.id);
+
+		if (guild) {
+			if (guild.available && data.unavailable) {
+				// guild is unavailable
+				guild.available = false;
+				client.emit(Constants.Events.GUILD_UNAVAILABLE, guild);
+			} else {
+				// delete guild
+				client.store.KillGuild(guild);
+			}
+		} else {
+			// it's not there! :(
+			client.emit('warn', 'guild deleted but not cached in first place. missed packet?');
+		}
+
+	}
+
+};
+
+module.exports = GuildDeleteHandler;

src/client/websocket/packets/handlers/GuildMemberAdd.js

@@ -0,0 +1,32 @@
+'use strict';
+
+// ##untested handler##
+
+const AbstractHandler = require('./AbstractHandler');
+const Structure = name => require(`../../../../structures/${name}`);
+
+const ClientUser = Structure('ClientUser');
+const Guild = Structure('Guild');
+
+const Constants = require('../../../../util/Constants');
+
+class GuildMemberAddHandler extends AbstractHandler {
+
+	constructor(packetManager) {
+		super(packetManager);
+	}
+
+	handle(packet) {
+		let data = packet.d;
+		let client = this.packetManager.client;
+
+		let guild = client.store.get('guilds', data.guild_id);
+
+		if (guild) {
+			guild._addMember(data);
+		}
+	}
+
+};
+
+module.exports = GuildMemberAddHandler;

src/client/websocket/packets/handlers/GuildMemberRemove.js

@@ -0,0 +1,33 @@
+'use strict';
+
+// ##untested handler##
+
+const AbstractHandler = require('./AbstractHandler');
+const Structure = name => require(`../../../../structures/${name}`);
+
+const ClientUser = Structure('ClientUser');
+const Guild = Structure('Guild');
+
+const Constants = require('../../../../util/Constants');
+
+class GuildMemberRemoveHandler extends AbstractHandler {
+
+	constructor(packetManager) {
+		super(packetManager);
+	}
+
+	handle(packet) {
+		let data = packet.d;
+		let client = this.packetManager.client;
+
+		let guild = client.store.get('guilds', data.guild_id);
+		let user = client.store.get('users', data.user.id);
+
+		if (guild && user) {
+			guild._removeMember(user);
+		}
+	}
+
+};
+
+module.exports = GuildMemberRemoveHandler;

src/client/websocket/packets/handlers/GuildMemberUpdate.js

@@ -0,0 +1,33 @@
+'use strict';
+
+// ##untested handler##
+
+const AbstractHandler = require('./AbstractHandler');
+const Structure = name => require(`../../../../structures/${name}`);
+
+const ClientUser = Structure('ClientUser');
+const Guild = Structure('Guild');
+
+const Constants = require('../../../../util/Constants');
+
+class GuildMemberUpdateHandler extends AbstractHandler {
+
+	constructor(packetManager) {
+		super(packetManager);
+	}
+
+	handle(packet) {
+		let data = packet.d;
+		let client = this.packetManager.client;
+
+		let guild = client.store.get('guilds', data.guild_id);
+		let user = client.store.get('users', data.user.id);
+
+		if (guild) {
+			guild._updateMember(user, data);
+		}
+	}
+
+};
+
+module.exports = GuildMemberUpdateHandler;

src/client/websocket/packets/handlers/GuildUpdate.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const AbstractHandler = require('./AbstractHandler');
+const Structure = name => require(`../../../../structures/${name}`);
+
+const ClientUser = Structure('ClientUser');
+const Guild = Structure('Guild');
+
+const Constants = require('../../../../util/Constants');
+const CloneObject = require('../../../../util/CloneObject');
+
+class GuildUpdateHandler extends AbstractHandler {
+
+	constructor(packetManager) {
+		super(packetManager);
+	}
+
+	handle(packet) {
+		let data = packet.d;
+		let client = this.packetManager.client;
+
+		let guild = client.store.get('guilds', data.id);
+
+		if (guild) {
+			client.store.UpdateGuild(guild, data);
+		}
+
+	}
+
+};
+
+module.exports = GuildUpdateHandler;

src/client/websocket/packets/handlers/Ready.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const AbstractHandler = require('./AbstractHandler');
+const Structure = name => require(`../../../../structures/${name}`);
+
+const ClientUser = Structure('ClientUser');
+const Guild = Structure('Guild');
+const DMChannel = Structure('DMChannel');
+
+class ReadyHandler extends AbstractHandler {
+
+	constructor(packetManager) {
+		super(packetManager);
+	}
+
+	handle(packet) {
+		let data = packet.d;
+		let client = this.packetManager.client;
+
+		client.manager.setupKeepAlive(data.heartbeat_interval);
+
+		client.store.user = client.store.add('users', new ClientUser(client, data.user));
+
+		for (let guild of data.guilds) {
+			client.store.NewGuild(guild);
+		}
+
+		for (let privateDM of data.private_channels) {
+			client.store.NewChannel(privateDM);
+		}
+
+	}
+
+};
+
+module.exports = ReadyHandler;