Skylar Grant
486ed80d31
Some checks failed
Silvanus Production Dockerization / build (push) Failing after 2m13s
271 lines
9.7 KiB
JavaScript
Executable File
271 lines
9.7 KiB
JavaScript
Executable File
/* eslint-disable no-case-declarations */
|
|
/* eslint-disable indent */
|
|
// dotenv for handling environment variables
|
|
const dotenv = require('dotenv');
|
|
dotenv.config();
|
|
const token = process.env.TOKEN;
|
|
const statusChannelId = process.env.STATUSCHANNELID;
|
|
const heartbeatUrl = process.env.HEARTBEAT_URL;
|
|
const sendHeartbeat = typeof heartbeatUrl === 'string';
|
|
|
|
// Discord.JS
|
|
const { Client, GatewayIntentBits, Partials, ActivityType } = require('discord.js');
|
|
const client = new Client({
|
|
intents: [
|
|
GatewayIntentBits.Guilds,
|
|
GatewayIntentBits.GuildMessages,
|
|
GatewayIntentBits.GuildMessageReactions,
|
|
GatewayIntentBits.MessageContent
|
|
],
|
|
partials: [
|
|
Partials.Channel,
|
|
Partials.Message
|
|
],
|
|
});
|
|
|
|
// Various imports
|
|
const fn = require('./modules/functions.js');
|
|
const strings = require('./data/strings.json');
|
|
const dbfn = require('./modules/dbfn.js');
|
|
const { GuildInfo } = require('./modules/CustomClasses.js');
|
|
const isDev = process.env.DEBUG === "true";
|
|
let statusChannel;
|
|
|
|
// Silvanus is being shut down: on launch, leave every guild and exit instead of starting normally.
|
|
const shuttingDown = true;
|
|
|
|
const farewellMessage = [
|
|
'Silvanus is being permanently shut down. Many of its core features are now built into Grow A Tree, and Discord has restricted bots\' access to message content, which Silvanus needs in order to work.',
|
|
'',
|
|
'It has been so much fun over the last few years. Thank you all for your support, and much love to you all!',
|
|
'',
|
|
'So long and thanks for all the apples 🍎',
|
|
'-Silvanus and @vfsh'
|
|
].join('\n');
|
|
|
|
// Post the farewell in the guild's reminder channel, falling back to its tree channel. Returns the channel used, if any.
|
|
async function sendFarewell(guild) {
|
|
const guildInfo = client.guildInfos.get(guild.id);
|
|
if (!guildInfo) return;
|
|
const channelIds = [...new Set([guildInfo.reminderChannelId, guildInfo.treeChannelId].filter(id => id))];
|
|
for (const channelId of channelIds) {
|
|
try {
|
|
const channel = await client.channels.fetch(channelId);
|
|
if (channel.guildId !== guild.id) continue;
|
|
await channel.send({ content: farewellMessage, allowedMentions: { parse: [] } });
|
|
return channel;
|
|
} catch (e) {
|
|
console.error(`Failed to send farewell to channel ${channelId} in ${guild.name} (${guild.id}): ${e}`);
|
|
}
|
|
}
|
|
}
|
|
|
|
async function leaveAllGuilds() {
|
|
// Skip the normal guildDelete handler, it depends on state that isn't built in shutdown mode
|
|
client.removeAllListeners('guildDelete');
|
|
statusChannel = await client.channels.fetch(statusChannelId).catch(e => console.error('Unable to fetch status channel', e));
|
|
const logStatus = async msg => {
|
|
console.log(msg);
|
|
if (statusChannel) await statusChannel.send(msg).catch(e => console.error(e));
|
|
};
|
|
// Load each guild's configured channels from the database so we know where to say goodbye
|
|
// If the database can't be read, abort without leaving anything so the shutdown can be retried
|
|
try {
|
|
await fn.collectionBuilders.guildInfos(client);
|
|
} catch (e) {
|
|
await logStatus(`Shutdown aborted, unable to load guild infos from the database: ${e}`);
|
|
client.destroy();
|
|
process.exit(1);
|
|
}
|
|
// Don't leave the server the status channel lives in until the end, so messages can still be sent
|
|
const guilds = [...client.guilds.cache.values()]
|
|
.sort((a, b) => (a.id === statusChannel?.guildId) - (b.id === statusChannel?.guildId));
|
|
await logStatus(`Shutting down: leaving ${guilds.length} guild(s)...`);
|
|
let farewellCount = 0;
|
|
for (const guild of guilds) {
|
|
// Once the bot leaves the dev server it can't post there anymore, so say goodbye first
|
|
if (guild.id === statusChannel?.guildId) await logStatus(`Leaving my final guild: ${guild.name} (${guild.id}). Goodbye, and thanks for all the trees. 🌳`);
|
|
const farewellChannel = await sendFarewell(guild);
|
|
if (farewellChannel) farewellCount++;
|
|
const farewellNote = farewellChannel ? `farewell sent in #${farewellChannel.name}` : 'no farewell sent';
|
|
await guild.leave()
|
|
.then(() => {
|
|
const msg = `I've left a guild: ${guild.name} (${guild.id}) -- ${farewellNote}`;
|
|
return guild.id === statusChannel?.guildId ? console.log(msg) : logStatus(msg);
|
|
})
|
|
.catch(e => logStatus(`Failed to leave guild: ${guild.name} (${guild.id}) -- ${e}`));
|
|
}
|
|
console.log(`Finished leaving guilds, sent ${farewellCount} farewell(s). Goodbye!`);
|
|
client.destroy();
|
|
process.exit(0);
|
|
}
|
|
|
|
client.once('ready', async () => {
|
|
if (shuttingDown) return leaveAllGuilds();
|
|
fn.collectionBuilders.slashCommands(client);
|
|
fn.collectionBuilders.dotCommands(client);
|
|
fn.collectionBuilders.setvalidCommands(client);
|
|
await fn.collectionBuilders.guildInfos(client);
|
|
await fn.collectionBuilders.messageCollectors(client);
|
|
const serverCount = client.guilds.cache.size;
|
|
// checkRateLimits();
|
|
console.log('Ready!');
|
|
client.user.setActivity({ name: `${serverCount} trees grow.`, type: ActivityType.Watching });
|
|
statusChannel = await client.channels.fetch(statusChannelId);
|
|
if (isDev == 'false') {
|
|
statusChannel.send(`${new Date().toISOString()} -- \nStartup Sequence Complete <@481933290912350209>`);
|
|
}
|
|
|
|
// Heartbeat Timer
|
|
if (sendHeartbeat) {
|
|
setInterval(() => {
|
|
fn.sendHeartbeat(heartbeatUrl);
|
|
}, 30000);
|
|
if (isDev) console.log("Heartbeat interval set.");
|
|
} else {
|
|
if (isDev) console.log("No heartbeat URL set, will not send heartbeats for uptime monitoring.");
|
|
}
|
|
});
|
|
|
|
// slash-commands
|
|
client.on('interactionCreate', async interaction => {
|
|
try {
|
|
if (interaction.isCommand()) {
|
|
if (isDev) {
|
|
// console.log(interaction);
|
|
}
|
|
const { commandName } = interaction;
|
|
|
|
if (client.slashCommands.has(commandName)) {
|
|
client.slashCommands.get(commandName).execute(interaction);
|
|
} else {
|
|
interaction.reply('Sorry, I don\'t have access to that command.');
|
|
console.error('Slash command attempted to run but not found: ' + commandName);
|
|
}
|
|
}
|
|
|
|
if (interaction.isButton()) {
|
|
switch (interaction.component.customId) {
|
|
case 'refresh':
|
|
// console.log(JSON.stringify(interaction));
|
|
await fn.refresh(interaction).catch(err => {
|
|
interaction.channel.send(fn.builders.errorEmbed("Oops! Something went wrong!"));
|
|
});
|
|
break;
|
|
case 'deleteping':
|
|
if (interaction.message.deletable) {
|
|
await interaction.message.delete().catch(err => {
|
|
// console.error(err);
|
|
});
|
|
}
|
|
break;
|
|
case 'waterpingrole':
|
|
const waterPingStatus = await fn.buttonHandlers.waterPing(interaction);
|
|
await interaction.reply(waterPingStatus).catch(e => console.error(e));
|
|
break;
|
|
case 'fruitpingrole':
|
|
const fruitPingStatus = await fn.buttonHandlers.fruitPing(interaction);
|
|
await interaction.reply(fruitPingStatus).catch(e => console.error(e));
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
} catch(err) {
|
|
if (err === "Guild doesn't exist in database!") {
|
|
interaction.channel.send(fn.builders.errorEmbed(strings.error.noGuild));
|
|
console.error(err);
|
|
} else {
|
|
interaction.channel.send("Oops! An error occurred... Sorry about that, please contact my owner @vfsh if this keeps happening.");
|
|
console.error(err);
|
|
}
|
|
}
|
|
|
|
});
|
|
|
|
client.on('messageUpdate', async (oldMessage, message) => {
|
|
await fn.messages.updateHandler(message).catch(async e => {
|
|
switch (e) {
|
|
case strings.error.noCompareMessage:
|
|
await message.channel.send(strings.error.noCompareMessage);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
});
|
|
});
|
|
|
|
client.on('messageCreate', async message => {
|
|
await fn.messages.updateHandler(message).catch(e => console.error(e));
|
|
|
|
// Dot Command Handling
|
|
// Some basic checking to prevent running unnecessary code
|
|
if (message.author.bot) return;
|
|
|
|
// Break the message down into its components and analyze it
|
|
const commandData = fn.dotCommands.getCommandData(message);
|
|
// if (isDev) console.log(commandData);
|
|
|
|
if (commandData.isValid && commandData.isCommand) {
|
|
try {
|
|
client.dotCommands.get(commandData.command).execute(message, commandData);
|
|
}
|
|
catch (error) {
|
|
console.error(error);
|
|
message.reply('There was an error trying to execute that command.');
|
|
}
|
|
}
|
|
return;
|
|
});
|
|
|
|
client.on('guildCreate', async guild => {
|
|
const serverCount = client.guilds.cache.size;
|
|
client.user.setActivity({ name: `${serverCount} trees grow.`, type: ActivityType.Watching });
|
|
await statusChannel.send(`I've been added to a new guild: ${guild.name} (${guild.id})`);
|
|
const guildInfo = new GuildInfo()
|
|
.setIds(guild.id, guild.ownerId);
|
|
const setBasicQuery = guildInfo.queryBuilder("setBasic");
|
|
await dbfn.setGuildInfo(setBasicQuery).catch(e => console.error(e));
|
|
});
|
|
|
|
client.on('guildDelete', async guild => {
|
|
const serverCount = client.guilds.cache.size;
|
|
client.user.setActivity({ name: `${serverCount} trees grow.`, type: ActivityType.Watching });
|
|
await statusChannel.send(`I've been removed from a guild: ${guild.name} (${guild.id})`);
|
|
if (client.guildInfos.has(guild.id)) {
|
|
let guildInfo = client.guildInfos.get(guild.id);
|
|
guildInfo.setReminders(undefined, undefined, undefined, undefined, false);
|
|
const setRemindersQuery = guildInfo.queryBuilder("setReminders");
|
|
await dbfn.setGuildInfo(setRemindersQuery);
|
|
}
|
|
});
|
|
|
|
async function checkRateLimits(hi) {
|
|
const axios = require('axios');
|
|
|
|
// Make a GET request to the Discord API
|
|
await axios.get('https://discord.com/api/v10/users/@me', {
|
|
headers: {
|
|
'Authorization': `Bot ${token}`
|
|
}
|
|
}).then(response => {
|
|
// Get the rate limit headers
|
|
const remaining = response.headers['x-ratelimit-remaining'];
|
|
const reset = response.headers['x-ratelimit-reset'];
|
|
|
|
// Log the rate limit headers
|
|
console.log(`Remaining requests: ${remaining}`);
|
|
console.log(`Reset time (Unix epoch seconds): ${reset}`);
|
|
}).catch(error => {
|
|
console.error(error);
|
|
});
|
|
await fn.sleep(500).then(async () =>{
|
|
await checkRateLimits();
|
|
})
|
|
}
|
|
|
|
process.on('unhandledRejection', error => {
|
|
console.error('Unhandled promise rejection (pls dont break up with me):', error);
|
|
});
|
|
|
|
client.login(token); |