Nomchy/discord.js
1
0
Fork 0
mirror of https://github.com/discordjs/discord.js.git synced 2026-03-11 09:03:29 +01:00
Code Issues Packages Projects Releases Wiki Activity

ESLint stuff...

Browse Source
This commit is contained in:
Amish Shah
2016-08-13 14:44:49 +01:00
parent 53d767ec04
commit b8db4c4f4b
74 changed files with 2574 additions and 2956 deletions
Download Patch File Download Diff File Expand all files Collapse all files

180
src/client/websocket/WebSocketManager.js
View File

@@ -1,5 +1,3 @@
'use strict';
const WebSocket = require('ws');
const Constants = require('../../util/Constants');
const zlib = require('zlib');
@@ -8,111 +6,111 @@ const WebSocketManagerDataStore = require('../../structures/datastore/WebSocketM
class WebSocketManager {
constructor(client) {
this.client = client;
this.ws = null;
this.packetManager = new PacketManager(this);
this.store = new WebSocketManagerDataStore();
this.status = Constants.Status.IDLE;
}
constructor(client) {
this.client = client;
this.ws = null;
this.packetManager = new PacketManager(this);
this.store = new WebSocketManagerDataStore();
this.status = Constants.Status.IDLE;
}
connect(gateway) {
this.status = Constants.Status.CONNECTING;
this.store.gateway = 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);
}
connect(gateway) {
this.status = Constants.Status.CONNECTING;
this.store.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) {
if (this.ws.readyState === WebSocket.OPEN) {
this.ws.send(JSON.stringify(data));
}
}
send(data) {
if (this.ws.readyState === WebSocket.OPEN) {
this.ws.send(JSON.stringify(data));
}
}
EventOpen() {
if (this.reconnecting) {
this._sendResume();
} else {
this._sendNewIdentify();
}
}
eventOpen() {
if (this.reconnecting) {
this._sendResume();
} else {
this._sendNewIdentify();
}
}
_sendResume() {
let payload = {
token: this.client.store.token,
session_id: this.store.sessionID,
seq: this.store.sequence,
};
_sendResume() {
const payload = {
token: this.client.store.token,
session_id: this.store.sessionID,
seq: this.store.sequence,
};
this.send({
op: Constants.OPCodes.RESUME,
d: payload,
});
}
this.send({
op: Constants.OPCodes.RESUME,
d: payload,
});
}
_sendNewIdentify() {
this.reconnecting = false;
let payload = this.client.options.ws;
payload.token = this.client.store.token;
_sendNewIdentify() {
this.reconnecting = false;
const payload = this.client.options.ws;
payload.token = this.client.store.token;
this.send({
op: Constants.OPCodes.IDENTIFY,
d: payload,
});
}
this.send({
op: Constants.OPCodes.IDENTIFY,
d: payload,
});
}
EventClose() {
if (!this.reconnecting) {
this.tryReconnect();
}
}
eventClose() {
if (!this.reconnecting) {
this.tryReconnect();
}
}
EventMessage(event) {
let packet;
try {
if (event.binary) {
event.data = zlib.inflateSync(event.data).toString();
}
eventMessage($event) {
let packet;
const event = $event;
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);
}
packet = JSON.parse(event.data);
} catch (e) {
return this.eventError(Constants.Errors.BAD_WS_MESSAGE);
}
this.packetManager.handle(packet);
}
return this.packetManager.handle(packet);
}
EventError(e) {
this.tryReconnect();
}
EventError() {
this.tryReconnect();
}
checkIfReady() {
if (this.status !== Constants.Status.READY) {
let unavailableCount = 0;
checkIfReady() {
if (this.status !== Constants.Status.READY) {
let unavailableCount = 0;
for (let guildID in this.client.store.data.guilds) {
unavailableCount += this.client.store.data.guilds[guildID].available ? 0 : 1;
}
for (const guildID in this.client.store.data.guilds) {
unavailableCount += this.client.store.data.guilds[guildID].available ? 0 : 1;
}
if (unavailableCount === 0) {
this.status = Constants.Status.READY;
this.client.emit(Constants.Events.READY);
this.packetManager.handleQueue();
}
}
}
if (unavailableCount === 0) {
this.status = Constants.Status.READY;
this.client.emit(Constants.Events.READY);
this.packetManager.handleQueue();
}
}
}
tryReconnect() {
this.status = Constants.Status.RECONNECTING;
this.ws.close();
this.packetManager.handleQueue();
this.client.emit(Constants.Events.RECONNECTING);
this.connect(this.store.gateway);
}
tryReconnect() {
this.status = Constants.Status.RECONNECTING;
this.ws.close();
this.packetManager.handleQueue();
this.client.emit(Constants.Events.RECONNECTING);
this.connect(this.store.gateway);
}
}
module.exports = WebSocketManager;

153
src/client/websocket/packets/WebSocketPacketManager.js
View File

@@ -1,100 +1,97 @@
'use strict';
const Constants = require('../../../util/Constants');
const BeforeReadyWhitelist = [
Constants.WSEvents.READY,
Constants.WSEvents.GUILD_CREATE,
Constants.WSEvents.GUILD_DELETE,
Constants.WSEvents.READY,
Constants.WSEvents.GUILD_CREATE,
Constants.WSEvents.GUILD_DELETE,
];
class WebSocketPacketManager {
constructor(websocketManager) {
this.ws = websocketManager;
this.handlers = {};
this.queue = [];
constructor(websocketManager) {
this.ws = websocketManager;
this.handlers = {};
this.queue = [];
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.GUILD_ROLE_CREATE, 'GuildRoleCreate');
this.register(Constants.WSEvents.GUILD_ROLE_DELETE, 'GuildRoleDelete');
this.register(Constants.WSEvents.GUILD_ROLE_UPDATE, 'GuildRoleUpdate');
this.register(Constants.WSEvents.GUILD_MEMBERS_CHUNK, 'GuildMembersChunk');
this.register(Constants.WSEvents.CHANNEL_CREATE, 'ChannelCreate');
this.register(Constants.WSEvents.CHANNEL_DELETE, 'ChannelDelete');
this.register(Constants.WSEvents.CHANNEL_UPDATE, 'ChannelUpdate');
this.register(Constants.WSEvents.PRESENCE_UPDATE, 'PresenceUpdate');
this.register(Constants.WSEvents.USER_UPDATE, 'UserUpdate');
this.register(Constants.WSEvents.VOICE_STATE_UPDATE, 'VoiceStateUpdate');
this.register(Constants.WSEvents.TYPING_START, 'TypingStart');
this.register(Constants.WSEvents.MESSAGE_CREATE, 'MessageCreate');
this.register(Constants.WSEvents.MESSAGE_DELETE, 'MessageDelete');
this.register(Constants.WSEvents.MESSAGE_UPDATE, 'MessageUpdate');
}
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.GUILD_ROLE_CREATE, 'GuildRoleCreate');
this.register(Constants.WSEvents.GUILD_ROLE_DELETE, 'GuildRoleDelete');
this.register(Constants.WSEvents.GUILD_ROLE_UPDATE, 'GuildRoleUpdate');
this.register(Constants.WSEvents.GUILD_MEMBERS_CHUNK, 'GuildMembersChunk');
this.register(Constants.WSEvents.CHANNEL_CREATE, 'ChannelCreate');
this.register(Constants.WSEvents.CHANNEL_DELETE, 'ChannelDelete');
this.register(Constants.WSEvents.CHANNEL_UPDATE, 'ChannelUpdate');
this.register(Constants.WSEvents.PRESENCE_UPDATE, 'PresenceUpdate');
this.register(Constants.WSEvents.USER_UPDATE, 'UserUpdate');
this.register(Constants.WSEvents.VOICE_STATE_UPDATE, 'VoiceStateUpdate');
this.register(Constants.WSEvents.TYPING_START, 'TypingStart');
this.register(Constants.WSEvents.MESSAGE_CREATE, 'MessageCreate');
this.register(Constants.WSEvents.MESSAGE_DELETE, 'MessageDelete');
this.register(Constants.WSEvents.MESSAGE_UPDATE, 'MessageUpdate');
}
get client() {
return this.ws.client;
}
get client() {
return this.ws.client;
}
register(event, handle) {
let Handler = require(`./handlers/${handle}`);
this.handlers[event] = new Handler(this);
}
register(event, handle) {
const Handler = require(`./handlers/${handle}`);
this.handlers[event] = new Handler(this);
}
handleQueue() {
for (let packetIndex in this.queue) {
this.handle(this.queue[packetIndex]);
this.queue.splice(packetIndex, 1);
}
}
handleQueue() {
this.queue.forEach((element, index) => {
this.handle(this.queue[index]);
this.queue.splice(index, 1);
});
}
setSequence(s) {
if (s && s > this.ws.store.sequence) {
this.ws.store.sequence = s;
}
}
setSequence(s) {
if (s && s > this.ws.store.sequence) {
this.ws.store.sequence = s;
}
}
handle(packet) {
handle(packet) {
if (packet.op === Constants.OPCodes.RECONNECT) {
this.setSequence(packet.s);
this.ws.tryReconnect();
return false;
}
if (packet.op === Constants.OPCodes.RECONNECT) {
this.setSequence(packet.s);
this.ws.tryReconnect();
return;
}
if (packet.op === Constants.OPCodes.INVALID_SESSION) {
this.ws._sendNewIdentify();
return false;
}
if (packet.op === Constants.OPCodes.INVALID_SESSION) {
this.ws._sendNewIdentify();
return;
}
if (this.ws.reconnecting) {
this.ws.reconnecting = false;
this.ws.checkIfReady();
}
if (this.ws.reconnecting) {
this.ws.reconnecting = false;
this.ws.checkIfReady();
}
this.setSequence(packet.s);
this.setSequence(packet.s);
if (this.ws.status !== Constants.Status.READY) {
if (BeforeReadyWhitelist.indexOf(packet.t) === -1) {
this.queue.push(packet);
return false;
}
}
if (this.ws.status !== Constants.Status.READY) {
if (BeforeReadyWhitelist.indexOf(packet.t) === -1) {
this.queue.push(packet);
return;
}
}
if (this.handlers[packet.t]) {
return this.handlers[packet.t].handle(packet);
}
if (this.handlers[packet.t]) {
return this.handlers[packet.t].handle(packet);
}
return false;
}
return false;
}
}

14
src/client/websocket/packets/handlers/AbstractHandler.js
View File

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

30
src/client/websocket/packets/handlers/ChannelCreate.js
View File

@@ -1,32 +1,20 @@
'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) {
const data = packet.d;
const client = this.packetManager.client;
handle(packet) {
let data = packet.d;
let client = this.packetManager.client;
const response = client.actions.ChannelCreate.handle(data);
let response = client.actions.ChannelCreate.handle(data);
if (response.channel) {
client.emit(Constants.Events.CHANNEL_CREATE, response.channel);
}
}
if (response.channel) {
client.emit(Constants.Events.CHANNEL_CREATE, response.channel);
}
}
};
}
module.exports = ChannelCreateHandler;

29
src/client/websocket/packets/handlers/ChannelDelete.js
View File

@@ -1,31 +1,20 @@
'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) {
const data = packet.d;
const client = this.packetManager.client;
handle(packet) {
let data = packet.d;
let client = this.packetManager.client;
const response = client.actions.ChannelDelete.handle(data);
let response = client.actions.ChannelDelete.handle(data);
if (response.channel) {
client.emit(Constants.Events.CHANNEL_DELETE, response.channel);
}
}
if (response.channel) {
client.emit(Constants.Events.CHANNEL_DELETE, response.channel);
}
}
};
}
module.exports = ChannelDeleteHandler;

42
src/client/websocket/packets/handlers/ChannelUpdate.js
View File

@@ -1,28 +1,14 @@
'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;
client.actions.ChannelUpdate.handle(data);
}
};
module.exports = ChannelUpdateHandler;
const AbstractHandler = require('./AbstractHandler');
class ChannelUpdateHandler extends AbstractHandler {
handle(packet) {
const data = packet.d;
const client = this.packetManager.client;
client.actions.ChannelUpdate.handle(data);
}
}
module.exports = ChannelUpdateHandler;

31
src/client/websocket/packets/handlers/GuildBanAdd.js
View File

@@ -1,33 +1,22 @@
'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) {
const data = packet.d;
const client = this.packetManager.client;
handle(packet) {
let data = packet.d;
let client = this.packetManager.client;
const guild = client.store.get('guilds', data.guild_id);
const user = client.store.get('users', data.user.id);
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);
}
}
if (guild && user) {
client.emit(Constants.Events.GUILD_BAN_ADD, guild, user);
}
}
};
}
module.exports = GuildBanAddHandler;

30
src/client/websocket/packets/handlers/GuildBanRemove.js
View File

@@ -1,33 +1,23 @@
'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) {
const data = packet.d;
const client = this.packetManager.client;
handle(packet) {
let data = packet.d;
let client = this.packetManager.client;
const guild = client.store.get('guilds', data.guild_id);
const user = client.store.get('users', data.user.id);
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);
}
}
if (guild && user) {
client.emit(Constants.Events.GUILD_BAN_REMOVE, guild, user);
}
}
};
}
module.exports = GuildBanRemoveHandler;

45
src/client/websocket/packets/handlers/GuildCreate.js
View File

@@ -1,38 +1,25 @@
'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) {
const data = packet.d;
const client = this.packetManager.client;
handle(packet) {
let data = packet.d;
let client = this.packetManager.client;
const guild = client.store.get('guilds', data.id);
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);
}
}
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;

30
src/client/websocket/packets/handlers/GuildDelete.js
View File

@@ -1,31 +1,19 @@
'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) {
const data = packet.d;
const client = this.packetManager.client;
handle(packet) {
let data = packet.d;
let client = this.packetManager.client;
const response = client.actions.GuildDelete.handle(data);
let response = client.actions.GuildDelete.handle(data);
if (response.guild) {
client.emit(Constants.Events.GUILD_DELETE, response.guild);
}
}
if (response.guild) {
client.emit(Constants.Events.GUILD_DELETE, response.guild);
}
}
};
}
module.exports = GuildDeleteHandler;

30
src/client/websocket/packets/handlers/GuildMemberAdd.js
View File

@@ -1,32 +1,20 @@
'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) {
const data = packet.d;
const client = this.packetManager.client;
handle(packet) {
let data = packet.d;
let client = this.packetManager.client;
const guild = client.store.get('guilds', data.guild_id);
let guild = client.store.get('guilds', data.guild_id);
if (guild) {
guild._addMember(data);
}
}
if (guild) {
guild._addMember(data);
}
}
};
}
module.exports = GuildMemberAddHandler;

24
src/client/websocket/packets/handlers/GuildMemberRemove.js
View File

@@ -1,28 +1,16 @@
'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) {
const data = packet.d;
const client = this.packetManager.client;
handle(packet) {
let data = packet.d;
let client = this.packetManager.client;
client.actions.GuildMemberRemove.handle(data);
}
let response = client.actions.GuildMemberRemove.handle(data);
}
};
}
module.exports = GuildMemberRemoveHandler;

36
src/client/websocket/packets/handlers/GuildMemberUpdate.js
View File

@@ -1,35 +1,23 @@
'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) {
const data = packet.d;
const client = this.packetManager.client;
handle(packet) {
let data = packet.d;
let client = this.packetManager.client;
const guild = client.store.get('guilds', data.guild_id);
let guild = client.store.get('guilds', data.guild_id);
if (guild) {
const member = guild.store.get('members', data.user.id);
if (member) {
guild._updateMember(member, data);
}
}
}
if (guild) {
let member = guild.store.get('members', data.user.id);
if (member) {
guild._updateMember(member, data);
}
}
}
};
}
module.exports = GuildMemberUpdateHandler;

34
src/client/websocket/packets/handlers/GuildMembersChunk.js
View File

@@ -1,33 +1,25 @@
'use strict';
// ##untested##
const AbstractHandler = require('./AbstractHandler');
const Structure = name => require(`../../../../structures/${name}`);
const Constants = require('../../../../util/Constants');
const CloneObject = require('../../../../util/CloneObject');
class GuildMembersChunkHandler extends AbstractHandler {
constructor(packetManager) {
super(packetManager);
}
handle(packet) {
const data = packet.d;
const client = this.packetManager.client;
const guild = client.store.get('guilds', data.guild_id);
handle(packet) {
let data = packet.d;
let client = this.packetManager.client;
let guild = client.store.get('guilds', data.guild_id);
const members = [];
if (guild) {
for (const member of guild.members) {
members.push(guild._addMember(member, true));
}
}
let members = [];
if (guild) {
for (let member of guild.members) {
members.push(guild._addMember(member, true));
}
}
client.emit(Constants.Events.GUILD_MEMBERS_CHUNK, guild, members);
}
client.emit(Constants.Events.GUILD_MEMBERS_CHUNK, guild, members);
}
};
}
module.exports = GuildMembersChunkHandler;

23
src/client/websocket/packets/handlers/GuildRoleCreate.js
View File

@@ -1,25 +1,14 @@
'use strict';
const AbstractHandler = require('./AbstractHandler');
const Structure = name => require(`../../../../structures/${name}`);
const Constants = require('../../../../util/Constants');
const Role = Structure('Role');
const Guild = Structure('Guild');
class GuildRoleCreateHandler extends AbstractHandler {
constructor(packetManager) {
super(packetManager);
}
handle(packet) {
const data = packet.d;
const client = this.packetManager.client;
handle(packet) {
let data = packet.d;
let client = this.packetManager.client;
client.actions.GuildRoleCreate.handle(data);
}
let response = client.actions.GuildRoleCreate.handle(data);
}
};
}
module.exports = GuildRoleCreateHandler;

39
src/client/websocket/packets/handlers/GuildRoleDelete.js
View File

@@ -1,25 +1,14 @@
'use strict';
const AbstractHandler = require('./AbstractHandler');
const Structure = name => require(`../../../../structures/${name}`);
const Constants = require('../../../../util/Constants');
const Role = Structure('Role');
const Guild = Structure('Guild');
class GuildRoleDeleteHandler extends AbstractHandler {
constructor(packetManager) {
super(packetManager);
}
handle(packet) {
let data = packet.d;
let client = this.packetManager.client;
let response = client.actions.GuildRoleDelete.handle(data);
}
};
module.exports = GuildRoleDeleteHandler;
const AbstractHandler = require('./AbstractHandler');
class GuildRoleDeleteHandler extends AbstractHandler {
handle(packet) {
const data = packet.d;
const client = this.packetManager.client;
client.actions.GuildRoleDelete.handle(data);
}
}
module.exports = GuildRoleDeleteHandler;

24
src/client/websocket/packets/handlers/GuildRoleUpdate.js
View File

@@ -1,26 +1,14 @@
'use strict';
const AbstractHandler = require('./AbstractHandler');
const Structure = name => require(`../../../../structures/${name}`);
const Constants = require('../../../../util/Constants');
const CloneObject = require('../../../../util/CloneObject');
const Role = Structure('Role');
const Guild = Structure('Guild');
class GuildRoleUpdateHandler extends AbstractHandler {
constructor(packetManager) {
super(packetManager);
}
handle(packet) {
const data = packet.d;
const client = this.packetManager.client;
handle(packet) {
let data = packet.d;
let client = this.packetManager.client;
client.actions.GuildRoleUpdate.handle(data);
}
let response = client.actions.GuildRoleUpdate.handle(data);
}
};
}
module.exports = GuildRoleUpdateHandler;

26
src/client/websocket/packets/handlers/GuildUpdate.js
View File

@@ -1,28 +1,14 @@
'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) {
const data = packet.d;
const client = this.packetManager.client;
handle(packet) {
let data = packet.d;
let client = this.packetManager.client;
client.actions.GuildUpdate.handle(data);
}
let response = client.actions.GuildUpdate.handle(data);
}
};
}
module.exports = GuildUpdateHandler;

28
src/client/websocket/packets/handlers/MessageCreate.js
View File

@@ -1,29 +1,19 @@
'use strict';
const AbstractHandler = require('./AbstractHandler');
const Structure = name => require(`../../../../structures/${name}`);
const Constants = require('../../../../util/Constants');
const Message = Structure('Message');
const Guild = Structure('Guild');
class MessageCreateHandler extends AbstractHandler {
constructor(packetManager) {
super(packetManager);
}
handle(packet) {
const data = packet.d;
const client = this.packetManager.client;
handle(packet) {
let data = packet.d;
let client = this.packetManager.client;
const response = client.actions.MessageCreate.handle(data);
let response = client.actions.MessageCreate.handle(data);
if (response.m) {
client.emit(Constants.Events.MESSAGE_CREATE, response.m);
}
}
if (response.m) {
client.emit(Constants.Events.MESSAGE_CREATE, response.m);
}
}
};
}
module.exports = MessageCreateHandler;

28
src/client/websocket/packets/handlers/MessageDelete.js
View File

@@ -1,29 +1,19 @@
'use strict';
const AbstractHandler = require('./AbstractHandler');
const Structure = name => require(`../../../../structures/${name}`);
const Constants = require('../../../../util/Constants');
const Message = Structure('Message');
const Guild = Structure('Guild');
class MessageDeleteHandler extends AbstractHandler {
constructor(packetManager) {
super(packetManager);
}
handle(packet) {
const data = packet.d;
const client = this.packetManager.client;
handle(packet) {
let data = packet.d;
let client = this.packetManager.client;
const response = client.actions.MessageDelete.handle(data);
let response = client.actions.MessageDelete.handle(data);
if (response.m) {
client.emit(Constants.Events.MESSAGE_DELETE, response.m);
}
}
if (response.m) {
client.emit(Constants.Events.MESSAGE_DELETE, response.m);
}
}
};
}
module.exports = MessageDeleteHandler;

25
src/client/websocket/packets/handlers/MessageUpdate.js
View File

@@ -1,27 +1,14 @@
'use strict';
const AbstractHandler = require('./AbstractHandler');
const Structure = name => require(`../../../../structures/${name}`);
const Constants = require('../../../../util/Constants');
const CloneObject = require('../../../../util/CloneObject');
const Message = Structure('Message');
const Guild = Structure('Guild');
class MessageUpdateHandler extends AbstractHandler {
constructor(packetManager) {
super(packetManager);
}
handle(packet) {
const data = packet.d;
const client = this.packetManager.client;
handle(packet) {
let data = packet.d;
let client = this.packetManager.client;
client.actions.MessageUpdate.handle(data);
}
let response = client.actions.MessageUpdate.handle(data);
}
};
}
module.exports = MessageUpdateHandler;

111
src/client/websocket/packets/handlers/PresenceUpdate.js
View File

@@ -1,75 +1,66 @@
'use strict';
const AbstractHandler = require('./AbstractHandler');
const Structure = name => require(`../../../../structures/${name}`);
const Constants = require('../../../../util/Constants');
const CloneObject = require('../../../../util/CloneObject');
const Role = Structure('User');
const cloneObject = require('../../../../util/CloneObject');
class PresenceUpdateHandler extends AbstractHandler {
constructor(packetManager) {
super(packetManager);
}
handle(packet) {
const data = packet.d;
const client = this.packetManager.client;
let user = client.store.get('users', data.user.id);
const guild = client.store.get('guilds', data.guild_id);
handle(packet) {
let data = packet.d;
let client = this.packetManager.client;
let user = client.store.get('users', data.user.id);
let guild = client.store.get('guilds', data.guild_id);
function makeUser(newUser) {
return client.store.newUser(newUser);
}
function makeUser(user) {
return client.store.NewUser(user);
}
// step 1
if (!user) {
if (data.user.username) {
user = makeUser(data.user);
} else {
return;
}
}
// step 1
if (!user) {
if (data.user.username) {
user = makeUser(data.user);
}else {
return;
}
}
if (guild) {
const memberInGuild = guild.store.get('members', user.id);
if (!memberInGuild) {
const member = guild._addMember({
user,
roles: data.roles,
deaf: false,
mute: false,
}, true);
client.emit(Constants.Events.GUILD_MEMBER_AVAILABLE, guild, member);
}
}
if (guild) {
let memberInGuild = guild.store.get('members', user.id);
if (!memberInGuild) {
let member = guild._addMember({
user,
roles: data.roles,
deaf: false,
mute: false,
}, true);
client.emit(Constants.Events.GUILD_MEMBER_AVAILABLE, guild, member);
}
}
data.user.username = data.user.username || user.username;
data.user.id = data.user.id || user.id;
data.user.discriminator = data.user.discriminator || user.discriminator;
data.user.username = data.user.username || user.username;
data.user.id = data.user.id || user.id;
data.user.discriminator = data.user.discriminator || user.discriminator;
// comment out avatar patching as it causes bugs (see #297)
// data.user.avatar = data.user.avatar || user.avatar;
data.user.status = data.status || user.status;
data.user.game = data.game;
// comment out avatar patching as it causes bugs (see #297)
// data.user.avatar = data.user.avatar || user.avatar;
data.user.status = data.status || user.status;
data.user.game = data.game;
const same = (
data.user.username === user.username &&
data.user.id === user.id &&
data.user.discriminator === user.discriminator &&
data.user.avatar === user.avatar &&
data.user.status === user.status &&
JSON.stringify(data.user.game) === JSON.stringify(user.game)
);
let same = (
data.user.username === user.username &&
data.user.id === user.id &&
data.user.discriminator === user.discriminator &&
data.user.avatar === user.avatar &&
data.user.status === user.status &&
JSON.stringify(data.user.game) === JSON.stringify(user.game)
);
if (!same) {
const oldUser = cloneObject(user);
user.setup(data.user);
client.emit(Constants.Events.PRESENCE_UPDATE, oldUser, user);
}
}
if (!same) {
let oldUser = CloneObject(user);
user.setup(data.user);
client.emit(Constants.Events.PRESENCE_UPDATE, oldUser, user);
}
}
};
}
module.exports = PresenceUpdateHandler;

43
src/client/websocket/packets/handlers/Ready.js
View File

@@ -1,39 +1,30 @@
'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 getStructure = name => require(`../../../../structures/${name}`);
const ClientUser = getStructure('ClientUser');
class ReadyHandler extends AbstractHandler {
constructor(packetManager) {
super(packetManager);
}
handle(packet) {
const data = packet.d;
const client = this.packetManager.client;
client.manager.setupKeepAlive(data.heartbeat_interval);
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));
client.store.user = client.store.add('users', new ClientUser(client, data.user));
for (const guild of data.guilds) {
client.store.newGuild(guild);
}
for (let guild of data.guilds) {
client.store.NewGuild(guild);
}
for (const privateDM of data.private_channels) {
client.store.newChannel(privateDM);
}
for (let privateDM of data.private_channels) {
client.store.NewChannel(privateDM);
}
this.packetManager.ws.store.sessionID = data.session_id;
this.packetManager.ws.store.sessionID = data.session_id;
this.packetManager.ws.checkIfReady();
}
this.packetManager.ws.checkIfReady();
}
};
}
module.exports = ReadyHandler;

82
src/client/websocket/packets/handlers/TypingStart.js
View File

@@ -1,60 +1,52 @@
'use strict';
const AbstractHandler = require('./AbstractHandler');
const Structure = name => require(`../../../../structures/${name}`);
const Constants = require('../../../../util/Constants');
const CloneObject = require('../../../../util/CloneObject');
class TypingData {
constructor(since, lastTimestamp, _timeout) {
this.since = since;
this.lastTimestamp = lastTimestamp;
this._timeout = _timeout;
}
constructor(since, lastTimestamp, _timeout) {
this.since = since;
this.lastTimestamp = lastTimestamp;
this._timeout = _timeout;
}
resetTimeout(_timeout) {
clearTimeout(this._timeout);
this._timeout = _timeout;
}
resetTimeout(_timeout) {
clearTimeout(this._timeout);
this._timeout = _timeout;
}
get elapsedTime() {
return Date.now() - this.since;
}
get elapsedTime() {
return Date.now() - this.since;
}
}
class TypingStartHandler extends AbstractHandler {
constructor(packetManager) {
super(packetManager);
}
handle(packet) {
const data = packet.d;
const client = this.packetManager.client;
const channel = client.store.get('channels', data.channel_id);
const user = client.store.get('users', data.user_id);
const timestamp = new Date(data.timestamp * 1000);
handle(packet) {
let data = packet.d;
let client = this.packetManager.client;
let channel = client.store.get('channels', data.channel_id);
let user = client.store.get('users', data.user_id);
let timestamp = new Date(data.timestamp * 1000);
function tooLate() {
return setTimeout(() => {
client.emit(Constants.Events.TYPING_STOP, channel, user, channel.typingMap[user.id]);
delete channel.typingMap[user.id];
}, 6000);
}
if (channel && user) {
if (channel.typingMap[user.id]) {
// already typing, renew
let mapping = channel.typingMap[user.id];
mapping.lastTimestamp = timestamp;
mapping.resetTimeout(tooLate());
} else {
channel.typingMap[user.id] = new TypingData(timestamp, timestamp, tooLate());
client.emit(Constants.Events.TYPING_START, channel, user);
}
}
if (channel && user) {
if (channel.typingMap[user.id]) {
// already typing, renew
const mapping = channel.typingMap[user.id];
mapping.lastTimestamp = timestamp;
mapping.resetTimeout(tooLate());
} else {
channel.typingMap[user.id] = new TypingData(timestamp, timestamp, tooLate());
client.emit(Constants.Events.TYPING_START, channel, user);
}
}
}
function tooLate() {
return setTimeout(() => {
client.emit(Constants.Events.TYPING_STOP, channel, user, channel.typingMap[user.id]);
delete channel.typingMap[user.id];
}, 6000);
}
}
};
}
module.exports = TypingStartHandler;

26
src/client/websocket/packets/handlers/UserUpdate.js
View File

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

57
src/client/websocket/packets/handlers/VoiceStateUpdate.js
View File

@@ -1,43 +1,34 @@
'use strict';
const AbstractHandler = require('./AbstractHandler');
const Structure = name => require(`../../../../structures/${name}`);
const Constants = require('../../../../util/Constants');
const CloneObject = require('../../../../util/CloneObject');
const Role = Structure('User');
const Constants = require('../../../../util/Constants');
const cloneObject = require('../../../../util/CloneObject');
class VoiceStateUpdateHandler extends AbstractHandler {
constructor(packetManager) {
super(packetManager);
}
handle(packet) {
const data = packet.d;
const client = this.packetManager.client;
const guild = client.store.get('guilds', data.guild_id);
handle(packet) {
let data = packet.d;
let client = this.packetManager.client;
let guild = client.store.get('guilds', data.guild_id);
if (guild) {
const member = guild.store.get('members', data.user_id);
if (member) {
const oldVoiceChannelMember = cloneObject(member);
if (member.voiceChannel && member.voiceChannel.id !== data.channel_id) {
member.voiceChannel.store.remove('members', oldVoiceChannelMember);
}
if (guild) {
let member = guild.store.get('members', data.user_id);
let channel = guild.store.get('channels', data.channel_id);
if (member) {
let oldVoiceChannelMember = CloneObject(member);
if (member.voiceChannel && member.voiceChannel.id !== data.channel_id) {
member.voiceChannel.store.remove('members', oldVoiceChannelMember);
}
member.serverMute = data.mute;
member.serverDeaf = data.deaf;
member.selfMute = data.self_mute;
member.selfDeaf = data.self_deaf;
member.voiceSessionID = data.session_id;
member.voiceChannelID = data.channel_id;
client.emit(Constants.Events.VOICE_STATE_UPDATE, oldVoiceChannelMember, member);
}
}
}
member.serverMute = data.mute;
member.serverDeaf = data.deaf;
member.selfMute = data.self_mute;
member.selfDeaf = data.self_deaf;
member.voiceSessionID = data.session_id;
member.voiceChannelID = data.channel_id;
client.emit(Constants.Events.VOICE_STATE_UPDATE, oldVoiceChannelMember, member);
}
}
}
};
}
module.exports = VoiceStateUpdateHandler;