mirror of
https://github.com/discordjs/discord.js.git
synced 2026-03-10 00:23:30 +01:00
376 lines
8.6 KiB
JavaScript
376 lines
8.6 KiB
JavaScript
"use strict";
|
|
|
|
var EventEmitter = require("events");
|
|
var request = require("superagent");
|
|
var WebSocket = require("ws");
|
|
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");
|
|
|
|
var User = require("../Structures/User.js"),
|
|
Channel = require("../Structures/Channel.js"),
|
|
TextChannel = require("../Structures/TextChannel.js"),
|
|
VoiceChannel = require("../Structures/VoiceChannel.js"),
|
|
PMChannel = require("../Structures/PMChannel.js"),
|
|
Server = require("../Structures/Server.js"),
|
|
Message = require("../Structures/Message.js");
|
|
|
|
var zlib;
|
|
|
|
class InternalClient {
|
|
constructor(discordClient) {
|
|
this.client = discordClient;
|
|
this.state = ConnectionState.IDLE;
|
|
this.websocket = null;
|
|
|
|
if (this.client.options.compress) {
|
|
zlib = require("zlib");
|
|
}
|
|
|
|
// creates 4 caches with discriminators based on ID
|
|
this.users = new Cache();
|
|
this.channels = new Cache();
|
|
this.servers = new Cache();
|
|
this.private_channels = new Cache();
|
|
this.resolver = new Resolver(this);
|
|
}
|
|
// def login
|
|
login(email, password) {
|
|
var self = this;
|
|
var client = self.client;
|
|
return new Promise((resolve, reject) => {
|
|
if (self.state === ConnectionState.DISCONNECTED || self.state === ConnectionState.IDLE) {
|
|
|
|
self.state = ConnectionState.LOGGING_IN;
|
|
|
|
request
|
|
.post(Endpoints.LOGIN)
|
|
.send({ email, password })
|
|
.end(function (err, res) {
|
|
|
|
if (err) {
|
|
self.state = ConnectionState.DISCONNECTED;
|
|
self.websocket = null;
|
|
client.emit("disconnected");
|
|
reject(new Error(err.response.text));
|
|
} else {
|
|
var token = res.body.token;
|
|
self.state = ConnectionState.LOGGED_IN;
|
|
self.token = token;
|
|
self.email = email;
|
|
self.password = password;
|
|
|
|
self.getGateway().then((url) => {
|
|
|
|
self.createWS(url);
|
|
resolve(token);
|
|
|
|
}).catch((e) => {
|
|
self.state = ConnectionState.DISCONNECTED;
|
|
client.emit("disconnected");
|
|
reject(new Error(err.response.text));
|
|
});
|
|
}
|
|
|
|
});
|
|
|
|
} else {
|
|
reject(new Error("already logging in/logged in/ready!"));
|
|
}
|
|
});
|
|
}
|
|
|
|
// def logout
|
|
logout() {
|
|
var self = this;
|
|
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) {
|
|
reject(new Error(err.response.text));
|
|
} else {
|
|
if (this.websocket) {
|
|
this.websocket.close();
|
|
this.websocket = null;
|
|
}
|
|
self.token = null;
|
|
self.email = null;
|
|
self.password = null;
|
|
self.state = ConnectionState.DISCONNECTED;
|
|
resolve();
|
|
}
|
|
});
|
|
|
|
});
|
|
}
|
|
|
|
// def startPM
|
|
startPM(resUser) {
|
|
var self = this;
|
|
return new Promise((resolve, reject) => {
|
|
var user = self.resolver.resolveUser(resUser);
|
|
|
|
if (user) {
|
|
|
|
// start the PM
|
|
request
|
|
.post(`${Endpoints.USER_CHANNELS(user.id) }`)
|
|
.set("authorization", self.token)
|
|
.send({
|
|
recipient_id: user.id
|
|
})
|
|
.end((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
|
|
getGateway() {
|
|
var self = this;
|
|
return new Promise((resolve, reject) => {
|
|
|
|
request
|
|
.get(Endpoints.GATEWAY)
|
|
.set("authorization", self.token)
|
|
.end(function (err, res) {
|
|
if (err)
|
|
reject(err);
|
|
else
|
|
resolve(res.body.url);
|
|
});
|
|
|
|
});
|
|
}
|
|
|
|
// 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 - "+e)));
|
|
|
|
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)
|
|
)
|
|
);
|
|
|
|
}
|
|
});
|
|
|
|
}
|
|
|
|
});
|
|
}
|
|
// def deleteMessage
|
|
deleteMessage(_message, options = {}) {
|
|
var self = this;
|
|
return new Promise((resolve, reject) => {
|
|
|
|
var message = self.resolver.resolveMessage(_message);
|
|
|
|
if (message) {
|
|
|
|
if (options.wait) {
|
|
setTimeout(deleteMsg, options.wait);
|
|
} else {
|
|
deleteMsg();
|
|
}
|
|
|
|
function deleteMsg() {
|
|
request
|
|
.del(Endpoints.CHANNEL_MESSAGE(message.channel.id, message.id))
|
|
.set("authorization", self.token)
|
|
.end((err, res) => {
|
|
if (err) {
|
|
reject(new Error(err.response.text));
|
|
} else {
|
|
message.channel.messages.remove(message);
|
|
resolve();
|
|
}
|
|
});
|
|
}
|
|
|
|
} else {
|
|
reject(new Error("Supplied message did not resolve to a message!"));
|
|
}
|
|
|
|
});
|
|
}
|
|
|
|
// def updateMessage
|
|
updateMessage(msg, _content, options = {}) {
|
|
|
|
var self = this;
|
|
return new Promise((resolve, reject) => {
|
|
|
|
var message = self.resolver.resolveMessage(msg);
|
|
|
|
if (message) {
|
|
|
|
var content = self.resolver.resolveString(_content);
|
|
var mentions = self.resolver.resolveMentions(content);
|
|
|
|
request
|
|
.patch(Endpoints.CHANNEL_MESSAGE(message.channel.id, message.id))
|
|
.set("authorization", self.token)
|
|
.send({
|
|
content: content,
|
|
tts: options.tts,
|
|
mentions: mentions
|
|
})
|
|
.end((err, res) => {
|
|
if (err) {
|
|
reject(new Error(err.response.text));
|
|
} else {
|
|
resolve(
|
|
message.channel.messages.update
|
|
(message, new Message(res.body, message.channel, self.client)
|
|
));
|
|
}
|
|
})
|
|
|
|
} else {
|
|
reject(new Error("Supplied message did not resolve to a message!"));
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
sendWS(object) {
|
|
this.websocket.send(JSON.stringify(object));
|
|
}
|
|
|
|
createWS(url) {
|
|
var self = this;
|
|
var client = self.client;
|
|
|
|
if (this.websocket)
|
|
return false;
|
|
|
|
this.websocket = new WebSocket(url);
|
|
|
|
this.websocket.onopen = () => {
|
|
|
|
self.sendWS({
|
|
op: 2,
|
|
d: {
|
|
token: self.token,
|
|
v: 3,
|
|
compress: self.client.options.compress,
|
|
properties: {
|
|
"$os": "discord.js",
|
|
"$browser": "discord.js",
|
|
"$device": "discord.js",
|
|
"$referrer": "discord.js",
|
|
"$referring_domain": "discord.js"
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
this.websocket.onclose = () => {
|
|
self.websocket = null;
|
|
self.state = ConnectionState.DISCONNECTED;
|
|
client.emit("disconnected");
|
|
}
|
|
|
|
this.websocket.onmessage = (e) => {
|
|
|
|
if (e.type === "Binary") {
|
|
if (!zlib) zlib = require("zlib");
|
|
e.data = zlib.inflateSync(e.data).toString();
|
|
}
|
|
|
|
var packet, data;
|
|
try {
|
|
packet = JSON.parse(e.data);
|
|
data = packet.d;
|
|
} catch (e) {
|
|
client.emit("error", e);
|
|
return;
|
|
}
|
|
|
|
client.emit("raw", packet);
|
|
|
|
switch (packet.t) {
|
|
|
|
case PacketType.READY:
|
|
var startTime = Date.now();
|
|
self.users.add(new User(data.user, client));
|
|
data.guilds.forEach((server) => {
|
|
self.servers.add(new Server(server, client));
|
|
});
|
|
data.private_channels.forEach((pm) => {
|
|
self.private_channels.add(new PMChannel(pm, client));
|
|
});
|
|
self.state = ConnectionState.READY;
|
|
|
|
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) {
|
|
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;
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
module.exports = InternalClient; |