1144 lines
58 KiB
JavaScript
1144 lines
58 KiB
JavaScript
const { EmbedBuilder, ActionRowBuilder, ButtonBuilder, ButtonStyle } = require("discord.js");
|
|
const { ApplicationCommandOptionType } = require("discord.js");
|
|
const bitfieldCalculator = require("discord-bitfield-calculator");
|
|
const { getDefaultSettings } = require("../database/guild");
|
|
const isDefined = require("../util/Validation.js");
|
|
|
|
module.exports = {
|
|
name: "config",
|
|
debug: false,
|
|
global: false,
|
|
description: "Configure your server settings",
|
|
usage: "[options] [configuration]",
|
|
permissions: {
|
|
channel: ["VIEW_CHANNEL", "SEND_MESSAGES", "EMBED_LINKS"],
|
|
member: ["MANAGE_GUILD"],
|
|
},
|
|
options: [
|
|
{
|
|
name: "killfeed",
|
|
description: "Configure the killfeed",
|
|
value: "killfeed",
|
|
type: ApplicationCommandOptionType.SubcommandGroup,
|
|
options: [
|
|
{
|
|
name: "channel",
|
|
description: "Configure the killfeed channel",
|
|
value: "channel",
|
|
type: ApplicationCommandOptionType.Subcommand,
|
|
options: [{
|
|
name: "channel",
|
|
description: "The channel to configure",
|
|
value: "channel",
|
|
type: ApplicationCommandOptionType.Channel,
|
|
required: true
|
|
}]
|
|
},
|
|
{
|
|
name: "show_coords",
|
|
description: "Show the coordinates of the victim in the killfeed channel.",
|
|
value: "show_coords",
|
|
type: ApplicationCommandOptionType.Subcommand,
|
|
options: [{
|
|
name: "configuration",
|
|
description: "True or False",
|
|
value: false,
|
|
type: ApplicationCommandOptionType.Boolean,
|
|
required: true,
|
|
}]
|
|
},
|
|
{
|
|
name: "show_weapon",
|
|
description: "Show the image of the weapon in the killfeed",
|
|
value: "show_weapon",
|
|
type: ApplicationCommandOptionType.Subcommand,
|
|
options: [{
|
|
name: "configuration",
|
|
description: "True or False",
|
|
value: false,
|
|
type: ApplicationCommandOptionType.Boolean,
|
|
required: true,
|
|
}]
|
|
}
|
|
]
|
|
},
|
|
{
|
|
name: "allowed_channels",
|
|
description: "Set channels you're allowed to use the bot in",
|
|
value: "allowed_channels",
|
|
type: ApplicationCommandOptionType.SubcommandGroup,
|
|
options: [
|
|
{
|
|
name: "add",
|
|
description: "Add channel",
|
|
value: "add",
|
|
type: ApplicationCommandOptionType.Subcommand,
|
|
options: [{
|
|
name: "channel",
|
|
description: "The channel to configure",
|
|
value: "channel",
|
|
type: ApplicationCommandOptionType.Channel,
|
|
channel_types: [0], // Restrict to text channel
|
|
required: true,
|
|
}]
|
|
},
|
|
{
|
|
name: "remove",
|
|
description: "Remove channel",
|
|
value: "remove",
|
|
type: ApplicationCommandOptionType.Subcommand,
|
|
options: [{
|
|
name: "channel",
|
|
description: "The channel to configure",
|
|
value: "channel",
|
|
type: ApplicationCommandOptionType.Channel,
|
|
channel_types: [0], // Restrict to text channel
|
|
required: true,
|
|
}]
|
|
},
|
|
{
|
|
name: "clear",
|
|
description: "Clears all configured channels",
|
|
value: "clear",
|
|
type: ApplicationCommandOptionType.Subcommand,
|
|
},
|
|
{
|
|
name: "view",
|
|
description: "View configured allowed channels",
|
|
value: "view",
|
|
type: ApplicationCommandOptionType.Subcommand,
|
|
}
|
|
]
|
|
},
|
|
{
|
|
name: "set_channel",
|
|
description: "Configure a channel",
|
|
value: "set_channel",
|
|
type: ApplicationCommandOptionType.Subcommand,
|
|
options: [
|
|
{
|
|
name: "channel_type",
|
|
description: "Select the channel type",
|
|
value: "channel_type",
|
|
type: ApplicationCommandOptionType.String,
|
|
choices: [
|
|
{ name: "Killfeed", value: "killfeedChannel" }, { name: "Admin Logs", value: "connectionLogsChannel" },
|
|
{ name: "Welcome", value: "welcomeChannel" }, { name: "Online Players", value: "activePlayersChannel" },
|
|
],
|
|
required: true,
|
|
},
|
|
{
|
|
name: "channel",
|
|
description: "The channel to configure",
|
|
value: "channel",
|
|
type: ApplicationCommandOptionType.Channel,
|
|
channel_types: [0], // Restrict to text channel
|
|
required: true,
|
|
},
|
|
]
|
|
},
|
|
{
|
|
name: "linked_gt_role",
|
|
description: "Role for users with linked gamertags",
|
|
value: "linked_gt_role",
|
|
type: ApplicationCommandOptionType.Subcommand,
|
|
options: [{
|
|
name: "role",
|
|
description: "Role to configure",
|
|
value: "role",
|
|
type: ApplicationCommandOptionType.Role,
|
|
required: true,
|
|
}]
|
|
},
|
|
{
|
|
name: "member_role",
|
|
description: "Role for users who join the server",
|
|
value: "member_role",
|
|
type: ApplicationCommandOptionType.Subcommand,
|
|
options: [{
|
|
name: "role",
|
|
description: "Role to configure",
|
|
value: "role",
|
|
type: ApplicationCommandOptionType.Role,
|
|
required: true,
|
|
}]
|
|
},
|
|
{
|
|
name: "bot_admin_role",
|
|
description: "Set/remove bot admin role",
|
|
value: "bot_admin_role",
|
|
type: ApplicationCommandOptionType.SubcommandGroup,
|
|
options: [
|
|
{
|
|
name: "add",
|
|
description: "Configure role to be bot admin",
|
|
value: "add",
|
|
type: ApplicationCommandOptionType.Subcommand,
|
|
options: [{
|
|
name: "role",
|
|
description: "Role to confiure",
|
|
value: "role",
|
|
type: ApplicationCommandOptionType.Role,
|
|
required: true,
|
|
}]
|
|
},
|
|
{
|
|
name: "remove",
|
|
description: "Remove configured role as bot admin",
|
|
value: "remove",
|
|
type: ApplicationCommandOptionType.Subcommand,
|
|
options: [{
|
|
name: "role",
|
|
description: "Role to remove",
|
|
value: "role",
|
|
type: ApplicationCommandOptionType.Role,
|
|
required: true,
|
|
}]
|
|
},
|
|
{
|
|
name: "view",
|
|
description: "View the configured bot admin roles",
|
|
value: "view",
|
|
type: ApplicationCommandOptionType.Subcommand,
|
|
}
|
|
]
|
|
},
|
|
{
|
|
name: "admin_ping_role",
|
|
description: "Admin role to ping in admin logs channel",
|
|
value: "admin_ping_role",
|
|
type: ApplicationCommandOptionType.Subcommand,
|
|
options: [{
|
|
name: "role",
|
|
description: "Role to configure",
|
|
value: "role",
|
|
type: ApplicationCommandOptionType.Role,
|
|
required: true,
|
|
}]
|
|
},
|
|
{
|
|
name: "exclude",
|
|
description: "Exclude roles that can be used to claim armbands",
|
|
value: "exclude",
|
|
type: ApplicationCommandOptionType.SubcommandGroup,
|
|
options: [
|
|
{
|
|
name: "add",
|
|
description: "Configure role to be excluded",
|
|
value: "add",
|
|
type: ApplicationCommandOptionType.Subcommand,
|
|
options: [{
|
|
name: "role",
|
|
description: "Role to confiure",
|
|
value: "role",
|
|
type: ApplicationCommandOptionType.Role,
|
|
required: true,
|
|
}]
|
|
},
|
|
{
|
|
name: "remove",
|
|
description: "Remove configured role thats excluded",
|
|
value: "remove",
|
|
type: ApplicationCommandOptionType.Subcommand,
|
|
options: [{
|
|
name: "role",
|
|
description: "Role to remove",
|
|
value: "role",
|
|
type: ApplicationCommandOptionType.Role,
|
|
required: true,
|
|
}]
|
|
},
|
|
{
|
|
name: "view",
|
|
description: "View the configured excluded roles",
|
|
value: "view",
|
|
type: ApplicationCommandOptionType.Subcommand,
|
|
},
|
|
]
|
|
},
|
|
{
|
|
name: "reset",
|
|
description: "Restore all settings to default configurations",
|
|
value: "reset",
|
|
type: ApplicationCommandOptionType.Subcommand,
|
|
},
|
|
{
|
|
name: "view",
|
|
description: "View current settings configuration",
|
|
value: "view",
|
|
type: ApplicationCommandOptionType.Subcommand,
|
|
},
|
|
{
|
|
name: "starting_balance",
|
|
description: "Set the starting balance of a new user",
|
|
value: "starting_balance",
|
|
type: ApplicationCommandOptionType.Subcommand,
|
|
options: [{
|
|
name: "amount",
|
|
description: "The amount to set the starting balance",
|
|
value: "amount",
|
|
type: ApplicationCommandOptionType.Number,
|
|
min_value: 1.00,
|
|
required: true,
|
|
}]
|
|
},
|
|
{
|
|
name: "uav-price",
|
|
description: "Configure the price of a UAV",
|
|
value: "uav-price",
|
|
type: ApplicationCommandOptionType.Subcommand,
|
|
options: [{
|
|
name: "amount",
|
|
description: "The amount to set the UAV price",
|
|
value: "amount",
|
|
type: ApplicationCommandOptionType.Number,
|
|
min_value: 0.01,
|
|
required: true,
|
|
}]
|
|
},
|
|
{
|
|
name: "emp-price",
|
|
description: "Configure the price of an EMP",
|
|
value: "emp-price",
|
|
type: ApplicationCommandOptionType.Subcommand,
|
|
options: [{
|
|
name: "amount",
|
|
description: "The amount to set the EMP price",
|
|
value: "amount",
|
|
type: ApplicationCommandOptionType.Number,
|
|
min_value: 0.01,
|
|
required: true,
|
|
}]
|
|
},
|
|
{
|
|
name: "income_role",
|
|
description: "Set/remove roles to recieve income",
|
|
value: "set_income_role",
|
|
type: ApplicationCommandOptionType.SubcommandGroup,
|
|
options: [
|
|
{
|
|
name: "set",
|
|
description: "Set role",
|
|
value: "set",
|
|
type: ApplicationCommandOptionType.Subcommand,
|
|
options: [
|
|
{
|
|
name: "role",
|
|
description: "Role to set",
|
|
value: "role",
|
|
type: ApplicationCommandOptionType.Role,
|
|
required: true,
|
|
},
|
|
{
|
|
name: "amount",
|
|
description: "The amount to collect",
|
|
value: 120.00,
|
|
type: ApplicationCommandOptionType.Number,
|
|
min_value: 0.01,
|
|
required: true,
|
|
}
|
|
]
|
|
},
|
|
{
|
|
name: "remove",
|
|
description: "Remove role",
|
|
value: "remove",
|
|
type: ApplicationCommandOptionType.Subcommand,
|
|
options: [{
|
|
name: "role",
|
|
description: "Role to remove",
|
|
value: "role",
|
|
type: ApplicationCommandOptionType.Role,
|
|
required: true,
|
|
}]
|
|
},
|
|
],
|
|
},
|
|
{
|
|
name: "income_limiter",
|
|
description: "Change the number of hours to wait before collecting next income",
|
|
value: "income_limiter",
|
|
type: ApplicationCommandOptionType.Subcommand,
|
|
options: [{
|
|
name: "hours",
|
|
description: "Number of hours till income can be collected",
|
|
value: 168.00, // 1 week
|
|
type: ApplicationCommandOptionType.Number,
|
|
min_value: 1.00,
|
|
required: true,
|
|
}]
|
|
},
|
|
{
|
|
name: "combat-log-timer",
|
|
description: "Adjust number of minutes to detect combat logs (0 disables combat log)",
|
|
value: "combat-log-timer",
|
|
type: ApplicationCommandOptionType.Subcommand,
|
|
options: [{
|
|
name: "minutes",
|
|
description: "Minutes to qualify combat log",
|
|
value: 5,
|
|
type: ApplicationCommandOptionType.Integer,
|
|
min_value: 0,
|
|
}]
|
|
},
|
|
{
|
|
name: "toggle-uav-purchase",
|
|
description: "Allow/Disallow UAV purchases",
|
|
value: "toggle-uav-purchase",
|
|
type: ApplicationCommandOptionType.Subcommand,
|
|
options: [{
|
|
name: "configuration",
|
|
description: "True or False",
|
|
value: false,
|
|
type: ApplicationCommandOptionType.Boolean,
|
|
required: true,
|
|
}]
|
|
},
|
|
{
|
|
name: "toggle-emp-purchase",
|
|
description: "Allow/Disallow EMP purchases",
|
|
value: "toggle-uav-purchase",
|
|
type: ApplicationCommandOptionType.Subcommand,
|
|
options: [{
|
|
name: "configuration",
|
|
description: "True or False",
|
|
value: false,
|
|
type: ApplicationCommandOptionType.Boolean,
|
|
required: true,
|
|
}]
|
|
},
|
|
{
|
|
name: "welcome_message_server_name",
|
|
description: "Configure the server name in the welcome message",
|
|
value: "welcome_message_server_name",
|
|
type: ApplicationCommandOptionType.Subcommand,
|
|
options: [{
|
|
name: "name",
|
|
description: "Server name to include in welcome message",
|
|
value: "name",
|
|
type: ApplicationCommandOptionType.String,
|
|
required: true,
|
|
}]
|
|
}
|
|
],
|
|
SlashCommand: {
|
|
/**
|
|
*
|
|
* @param {require("../structures/DayzRBot")} client
|
|
* @param {import("discord.js").Message} message
|
|
* @param {string[]} args
|
|
* @param {*} param3
|
|
*/
|
|
run: async (client, interaction, args, { GuildDB }) => {
|
|
const permissions = bitfieldCalculator.permissions(interaction.member.permissions);
|
|
let canUseCommand = false;
|
|
|
|
if (permissions.includes("MANAGE_GUILD")) canUseCommand = true;
|
|
if (GuildDB.hasBotAdmin && interaction.member.roles.filter(e => GuildDB.botAdminRoles.indexOf(e) !== -1).length > 0) canUseCommand = true;
|
|
if (!canUseCommand) return interaction.send({ content: "You don\"t have the permissions to use this command." });
|
|
|
|
switch (args[0].name) {
|
|
|
|
case "allowed_channels":
|
|
const channels_config = args[0].options[0].name;
|
|
const channelid = ["add", "remove"].includes(channels_config) ? args[0].options[0].options[0].value : null;
|
|
|
|
if (channels_config == "add") {
|
|
const channelAdd = client.GetChannel(channelid);
|
|
|
|
const newChannelErrorEmbed = new EmbedBuilder().setColor(client.config.Colors.Red)
|
|
let error = false;
|
|
|
|
if (!channelAdd) { error = true; newChannelErrorEmbed.setDescription(`**Error Notice:** Cannot find that channel.`); }
|
|
if (channelAdd.type == "voice") { error = true; newChannelErrorEmbed.setDescription(`**Error Notice:** Cannot add voice channel to allowed channels.`); }
|
|
if (error) return interaction.send({ embeds: [newChannelErrorEmbed] });
|
|
|
|
client.dbo.collection("guilds").updateOne({ "server.serverID": GuildDB.serverID }, { $push: { "server.allowedChannels": channelid } }, (err, res) => {
|
|
if (err) return client.sendInternalError(interaction, err);
|
|
});
|
|
|
|
const successAddChannelEmbed = new EmbedBuilder()
|
|
.setColor(client.config.Colors.Green)
|
|
.setDescription(`**Success:** Set <#${channelid}> as an allowed channel.`);
|
|
|
|
return interaction.send({ embeds: [successAddChannelEmbed] });
|
|
} else if (channels_config == "remove") {
|
|
|
|
const errorChannelNotAvailable = new EmbedBuilder()
|
|
.setDescription(`**Error Notice:** <#${channelid}> is not in allowed channels.`)
|
|
.setColor(client.config.Colors.Red)
|
|
|
|
if (!GuildDB.allowedChannels.includes(channelid)) return interaction.send({ embeds: [errorChannelNotAvailable] });
|
|
|
|
const promptRemoveChannel = new EmbedBuilder()
|
|
.setTitle(`Are you sure you want to remove this channel from allowed channels?`)
|
|
.setColor(client.config.Colors.Default)
|
|
|
|
const optRemoveChannel = new ActionRowBuilder()
|
|
.addComponents(
|
|
new ButtonBuilder()
|
|
.setCustomId(`RemoveAllowedChannels-yes-${channelid}-${interaction.member.user.id}`)
|
|
.setLabel("Yes")
|
|
.setStyle(ButtonStyle.Danger),
|
|
new ButtonBuilder()
|
|
.setCustomId(`RemoveAllowedChannels-no-${channelid}-${interaction.member.user.id}`)
|
|
.setLabel("No")
|
|
.setStyle(ButtonStyle.Success)
|
|
)
|
|
|
|
return interaction.send({ embeds: [promptRemoveChannel], components: [optRemoveChannel], flags: (1 << 6) });
|
|
|
|
} else if (channels_config == "clear") {
|
|
|
|
const errorNoAllowedChannels = new EmbedBuilder()
|
|
.setDescription(`**Error Notice:**\n> No allowed channels configured to clear`)
|
|
.setColor(client.config.Colors.Red)
|
|
|
|
if (GuildDB.allowedChannels.length == 0) return interaction.send({ embeds: [errorNoAllowedChannels] });
|
|
|
|
const promptClearChannels = new EmbedBuilder()
|
|
.setTitle(`Are you sure you want to clear all configured channels from allowed channels?`)
|
|
.setColor(client.config.Colors.Default)
|
|
|
|
const optClearChannels = new ActionRowBuilder()
|
|
.addComponents(
|
|
new ButtonBuilder()
|
|
.setCustomId(`ClearAllowedChannels-yes-${interaction.member.user.id}`)
|
|
.setLabel("Yes")
|
|
.setStyle(ButtonStyle.Danger),
|
|
new ButtonBuilder()
|
|
.setCustomId(`ClearAllowedChannels-no-${interaction.member.user.id}`)
|
|
.setLabel("No")
|
|
.setStyle(ButtonStyle.Success)
|
|
)
|
|
|
|
return interaction.send({ embeds: [promptClearChannels], components: [optClearChannels], flags: (1 << 6) });
|
|
|
|
|
|
} else if (channels_config == "view") {
|
|
|
|
if (!GuildDB.customChannelStatus) {
|
|
const noConfiguredChannels = new EmbedBuilder()
|
|
.setColor(client.config.Colors.Default)
|
|
.setTitle("Channels")
|
|
.setDescription("> There are no configured channels");
|
|
|
|
return interaction.send({ embeds: [noConfiguredChannels] });
|
|
}
|
|
|
|
const configuredChannels = new EmbedBuilder()
|
|
.setColor(client.config.Colors.Default)
|
|
.setTitle("Channels")
|
|
|
|
let des = "";
|
|
for (let i = 0; i < GuildDB.allowedChannels.length; i++) {
|
|
if (i == 0) des += `> <#${GuildDB.allowedChannels[i]}>`;
|
|
else des += `\n> <#${GuildDB.allowedChannels[i]}>`;
|
|
}
|
|
configuredChannels.setDescription(des);
|
|
|
|
return interaction.send({ embeds: [configuredChannels] });
|
|
|
|
}
|
|
|
|
case "bot_admin_role":
|
|
const bot_admin_config = args[0].options[0].name;
|
|
const botAdminRoleId = ["add", "remove"].includes(bot_admin_config) ? args[0].options[0].options[0].value : null;
|
|
if (bot_admin_config == "add") {
|
|
|
|
client.dbo.collection("guilds").updateOne({ "server.serverID": GuildDB.serverID }, { $push: { "server.botAdminRoles": botAdminRoleId } }, (err, res) => {
|
|
if (err) return client.sendInternalError(interaction, err);
|
|
});
|
|
|
|
const successSetBotAdminRoleEmbed = new EmbedBuilder()
|
|
.setDescription(`Successfully added <@&${botAdminRoleId}> as a bot admin role.\nUsers with this role can use restricted commands.`)
|
|
.setColor(client.config.Colors.Green);
|
|
|
|
return interaction.send({ embeds: [successSetBotAdminRoleEmbed] });
|
|
|
|
} else if (bot_admin_config == "remove") {
|
|
|
|
if (!GuildDB.botAdminRoles.includes(botAdminRoleId)) {
|
|
const nonAdminRoleEmbed = new EmbedBuilder()
|
|
.setColor(client.config.Colors.Yellow)
|
|
.setDescription(`**Notice:**\n> The role <@&${botAdminRoleId}> has not been configured as a bot admin.`);
|
|
|
|
return interaction.send({ embeds: [nonAdminRoleEmbed] });
|
|
}
|
|
|
|
const promptRemoveAdminRole = new EmbedBuilder()
|
|
.setTitle(`Are you sure you want to remove this role as a bot admin?`)
|
|
.setColor(client.config.Colors.Default)
|
|
|
|
const optRemoveAdminRole = new ActionRowBuilder()
|
|
.addComponents(
|
|
new ButtonBuilder()
|
|
.setCustomId(`RemoveBotAdminRole-yes-${botAdminRoleId}-${interaction.member.user.id}`)
|
|
.setLabel("Yes")
|
|
.setStyle(ButtonStyle.Danger),
|
|
new ButtonBuilder()
|
|
.setCustomId(`RemoveBotAdminRole-no-${botAdminRoleId}-${interaction.member.user.id}`)
|
|
.setLabel("No")
|
|
.setStyle(ButtonStyle.Success)
|
|
)
|
|
|
|
return interaction.send({ embeds: [promptRemoveAdminRole], components: [optRemoveAdminRole], flags: (1 << 6) });
|
|
|
|
} else if (bot_admin_config == "view") {
|
|
|
|
if (GuildDB.botAdminRoles.length == 0) {
|
|
const noBotAdminRoles = new EmbedBuilder()
|
|
.setColor(client.config.Colors.Default)
|
|
.setTitle("Admin Roles")
|
|
.setDescription("> There have been no configured admin roles");
|
|
|
|
return interaction.send({ embeds: [noBotAdminRoles] });
|
|
}
|
|
|
|
const botAdminRolesEmbed = new EmbedBuilder()
|
|
.setColor(client.config.Colors.Default)
|
|
.setTitle("Admin Roles")
|
|
|
|
let des = "";
|
|
for (let i = 0; i < GuildDB.botAdminRoles.length; i++) {
|
|
des += `\n> <@&${GuildDB.botAdminRoles[i]}>`;
|
|
}
|
|
botAdminRolesEmbed.setDescription(des);
|
|
|
|
return interaction.send({ embeds: [botAdminRolesEmbed] });
|
|
|
|
}
|
|
|
|
case "admin_ping_role":
|
|
client.dbo.collection("guilds").updateOne({ "server.serverID": GuildDB.serverID }, { $set: { "server.adminRole": args[0].options[0].value } }, (err, res) => {
|
|
if (err) return client.sendInternalError(interaction, err);
|
|
});
|
|
|
|
const successSetAdminRoleEmbed = new EmbedBuilder()
|
|
.setDescription(`Successfully set <@&${args[0].options[0].value}> as the server admin role..`)
|
|
.setColor(client.config.Colors.Green);
|
|
|
|
return interaction.send({ embeds: [successSetAdminRoleEmbed] });
|
|
|
|
case "exclude":
|
|
const exclude_config = args[0].options[0].name;
|
|
const exclude_roleid = ["add", "remove"].includes(exclude_config) ? args[0].options[0].options[0].value : null;
|
|
|
|
if (exclude_config == "add") {
|
|
client.dbo.collection("guilds").updateOne({ "server.serverID": GuildDB.serverID }, { $push: { "server.excludedRoles": exclude_roleid } }, (err, res) => {
|
|
if (err) return client.sendInternalError(interaction, err);
|
|
})
|
|
|
|
const successExcludeEmbed = new EmbedBuilder()
|
|
.setColor(client.config.Colors.Green)
|
|
.setDescription(`**Done!**\n> Successfully added <@&${exclude_roleid}> to list of excluded roles.`)
|
|
|
|
return interaction.send({ embeds: [successExcludeEmbed] });
|
|
|
|
} else if (exclude_config == "remove") {
|
|
client.dbo.collection("guilds").updateOne({ "server.serverID": GuildDB.serverID }, { $pull: { "server.excludedRoles": exclude_roleid } }, (err, res) => {
|
|
if (err) return client.sendInternalError(interaction, err);
|
|
})
|
|
|
|
const successRemoveExcludeEmbed = new EmbedBuilder()
|
|
.setColor(client.config.Colors.Green)
|
|
.setDescription(`**Done!**\n> Successfully removed <@&${exclude_roleid}> to list of excluded roles.`)
|
|
|
|
return interaction.send({ embeds: [successRemoveExcludeEmbed] });
|
|
|
|
} else if (exclude_config == "view") {
|
|
|
|
if (GuildDB.excludedRoles.length == 0) {
|
|
const noExcludedRoles = new EmbedBuilder()
|
|
.setColor(client.config.Colors.Default)
|
|
.setTitle("Excluded Roles")
|
|
.setDescription("> There have been no excluded roles");
|
|
|
|
return interaction.send({ embeds: [noExcludedRoles] });
|
|
}
|
|
|
|
const excludedRolesEmbed = new EmbedBuilder()
|
|
.setColor(client.config.Colors.Default)
|
|
.setTitle("Excluded Roles")
|
|
|
|
let des = "";
|
|
for (let i = 0; i < GuildDB.excludedRoles.length; i++) {
|
|
des += `\n> <@&${GuildDB.excludedRoles[i]}>`;
|
|
}
|
|
excludedRolesEmbed.setDescription(des);
|
|
|
|
return interaction.send({ embeds: [excludedRolesEmbed] });
|
|
|
|
}
|
|
|
|
case "reset":
|
|
const promptReset = new EmbedBuilder()
|
|
.setTitle(`Woah!? Hold on.`)
|
|
.setDescription("Are you sure you wish to remove all your configurations for this guild?")
|
|
.setColor(client.config.Colors.Default)
|
|
|
|
const optReset = new ActionRowBuilder()
|
|
.addComponents(
|
|
new ButtonBuilder()
|
|
.setCustomId(`ResetSettings-yes-${interaction.member.user.id}`)
|
|
.setLabel("Yes")
|
|
.setStyle(ButtonStyle.Danger),
|
|
new ButtonBuilder()
|
|
.setCustomId(`ResetSettings-no-${interaction.member.user.id}`)
|
|
.setLabel("No")
|
|
.setStyle(ButtonStyle.Success)
|
|
)
|
|
|
|
return interaction.send({ embeds: [promptReset], components: [optReset], flags: (1 << 6) });
|
|
|
|
case "view":
|
|
|
|
// wrappers
|
|
const w = "\`\`\`";
|
|
const a = "ansi\n";
|
|
const f = "fix\n";
|
|
const m = "arm\n"
|
|
const g = "[2;32m";
|
|
const r = "[2;31m";
|
|
|
|
// boolean display
|
|
const autoRestart = GuildDB.autoRestart ? `${g}true` : `${r}false`;
|
|
const showKillfeedCoords = GuildDB.showKillfeedCoords ? `${g}true` : `${r}false`;
|
|
const showKillfeedWeapon = GuildDB.showKillfeedWeapon ? `${g}true` : `${r}false`;
|
|
const purchaseUAV = GuildDB.purchaseUAV ? `${g}true` : `${r}false`;
|
|
const purchaseEMP = GuildDB.purchaseEMP ? `${g}true` : `${r}false`;
|
|
const adminRoles = GuildDB.hasBotAdmin ? `${g}true` : `${r}false`
|
|
const excludedRoles = GuildDB.hasExcludedRoles ? `${g}true` : `${r}false`;
|
|
|
|
// Role / channel display
|
|
const NONE = `${w}${m}none${w}`;
|
|
const channelsInfo = GuildDB.customChannelStatus ? "\`</channels:1225869620813107246>\` to view" : NONE;
|
|
const killfeedChannel = isDefined(GuildDB.killfeedChannel) ? `<#${GuildDB.killfeedChannel}>` : NONE;
|
|
const connectionLogs = isDefined(GuildDB.connectionLogsChannel) ? `<#${GuildDB.connectionLogsChannel}>` : NONE;
|
|
const activePlayers = isDefined(GuildDB.activePlayersChannel) ? `<#${GuildDB.activePlayersChannel}>` : NONE;
|
|
const welcomeChannel = isDefined(GuildDB.welcomeChannel) ? `<#${GuildDB.welcomeChannel}>` : NONE;
|
|
const linkedGTRole = isDefined(GuildDB.linkedGamertagRole) ? `<@&${GuildDB.linkedGamertagRole}>` : NONE;
|
|
const memberRole = isDefined(GuildDB.memberRole) ? `<@&${GuildDB.memberRole}>` : NONE;
|
|
|
|
// value display
|
|
const incomeLimiter = `${GuildDB.incomeLimiter} hours`;
|
|
const startingBalance = `$${GuildDB.startingBalance.toLocaleString(undefined, { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
|
|
const uavPrice = `$${GuildDB.uavPrice.toLocaleString(undefined, { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
|
|
const empPrice = `$${GuildDB.empPrice.toLocaleString(undefined, { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
|
|
const combatLogTimer = `${GuildDB.combatLogTimer} minutes`;
|
|
|
|
// Ugly below but kinda nice above
|
|
const settingsEmbed = new EmbedBuilder()
|
|
.setColor(client.config.Colors.Default)
|
|
.setTitle("Current Guild Configurations")
|
|
.addFields(
|
|
{ name: "Guild ID", value: `${w}${f}${GuildDB.serverID}${w}`, inline: true },
|
|
{ name: "Server Name", value: `${w}${f}${GuildDB.serverName}${w}`, inline: true },
|
|
{ name: "Auto Restart", value: `${w}${a}${autoRestart}${w}`, inline: true },
|
|
{ name: "UAVs Enabled", value: `${w}${a}${purchaseUAV}${w}`, inline: true },
|
|
{ name: "EMPs Enabled", value: `${w}${a}${purchaseEMP}${w}`, inline: true },
|
|
{ name: "Show Killfeed Coords", value: `${w}${a}${showKillfeedCoords}${w}`, inline: true },
|
|
{ name: "Show Killfeed Weapons", value: `${w}${a}${showKillfeedWeapon}${w}`, inline: true },
|
|
{ name: "Has Admin Rols", value: `${w}${a}${adminRoles}${w}`, inline: true },
|
|
{ name: "Has Excluded Roles", value: `${w}${a}${excludedRoles}${w}`, inline: true },
|
|
{ name: "Allowed Channels", value: `${channelsInfo}`, inline: true },
|
|
{ name: "Killfeed Channel", value: `${killfeedChannel}`, inline: true },
|
|
{ name: "Connection Logs Channel", value: `${connectionLogs}`, inline: true },
|
|
{ name: "Player List Channel", value: `${activePlayers}`, inline: true },
|
|
{ name: "Welcome Channel", value: `${welcomeChannel}`, inline: true },
|
|
{ name: "Linked Gamertag Role", value: `${linkedGTRole}`, inline: true },
|
|
{ name: "Member Role", value: `${memberRole}`, inline: true },
|
|
{ name: "Income Limiter", value: `${w}${f}${incomeLimiter}${w}`, inline: true },
|
|
{ name: "Starting Balance", value: `${w}${f}${startingBalance}${w}`, inline: true },
|
|
{ name: "UAV Price", value: `${w}${f}${uavPrice}${w}`, inline: true },
|
|
{ name: "EMP Price", value: `${w}${f}${empPrice}${w}`, inline: true },
|
|
{ name: "Combat Log Timer", value: `${w}${f}${combatLogTimer}${w}`, inline: true },
|
|
);
|
|
|
|
return interaction.send({ embeds: [settingsEmbed] });
|
|
|
|
case "set_channel":
|
|
const channelType = args[0].options[0].value;
|
|
const channel = args[0].options[1].value;
|
|
|
|
client.dbo.collection("guilds").updateOne({ "server.serverID": GuildDB.serverID }, { $set: { [`server.${channelType}`]: channel } }, (err, res) => {
|
|
if (err) return client.sendInternalError(interaction, err);
|
|
});
|
|
|
|
const successSetChannelEmbed = new EmbedBuilder()
|
|
.setDescription(`Successfully set <#${channel}> as the ${channelType} channel.`)
|
|
.setColor(client.config.Colors.Green);
|
|
|
|
return interaction.send({ embeds: [successSetChannelEmbed] });
|
|
|
|
case "linked_gt_role":
|
|
const linked_gt_role = args[0].options[0].value;
|
|
|
|
client.dbo.collection("guilds").updateOne({ "server.serverID": GuildDB.serverID }, { $set: { "server.linkedGamertagRole": linked_gt_role } }, (err, res) => {
|
|
if (err) return client.sendInternalError(interaction, err);
|
|
});
|
|
|
|
const successLinkedGTRoleEmbed = new EmbedBuilder()
|
|
.setDescription(`Successfully set <@&${linked_gt_role}> to give to users who link their gamertag.`)
|
|
.setColor(client.config.Colors.Green);
|
|
|
|
return interaction.send({ embeds: [successLinkedGTRoleEmbed] });
|
|
|
|
case "member_role":
|
|
const member_role = args[0].options[0].value;
|
|
|
|
client.dbo.collection("guilds").updateOne({ "server.serverID": GuildDB.serverID }, { $set: { "server.memberRole": member_role } }, (err, res) => {
|
|
if (err) return client.sendInternalError(interaction, err);
|
|
});
|
|
|
|
const successMemberRoleEmbed = new EmbedBuilder()
|
|
.setDescription(`Successfully set <@&${member_role}> to give to users who link they join.`)
|
|
.setColor(client.config.Colors.Green);
|
|
|
|
return interaction.send({ embeds: [successMemberRoleEmbed] });
|
|
|
|
case "starting_balance":
|
|
client.dbo.collection("guilds").updateOne({ "server.serverID": GuildDB.serverID }, { $set: { "server.startingBalance": args[0].options[0].value } }, (err, res) => {
|
|
if (err) return client.sendInternalError(interaction, err);
|
|
});
|
|
|
|
let successSetStartingBalanceEmbed = new EmbedBuilder()
|
|
.setColor(client.config.Colors.Green)
|
|
.setDescription(`Successfully set $${args[0].options[0].value.toFixed(2)} as starting balance`);
|
|
|
|
return interaction.send({ embeds: [successSetStartingBalanceEmbed] });
|
|
|
|
case "income_role":
|
|
if (args[0].options[0].name == "set") {
|
|
const incomeRoleId = args[0].options[0].options[0].value
|
|
|
|
if (args[0].options[0].options[1].value <= 0) {
|
|
let errorIncomeAmount = new EmbedBuilder()
|
|
.setDescription("**Error Notice:** Amount cannot be $0 or less than $0.")
|
|
.setColor(client.config.Colors.Red);
|
|
|
|
return interaction.send({ embeds: [errorIncomeAmount] });
|
|
}
|
|
|
|
const searchIndex = GuildDB.incomeRoles.findIndex((role) => role.role == incomeRoleId);
|
|
if (searchIndex == -1) {
|
|
const newIncome = {
|
|
role: incomeRoleId,
|
|
income: args[0].options[0].options[1].value,
|
|
}
|
|
|
|
client.dbo.collection("guilds").updateOne({ "server.serverID": GuildDB.serverID }, { $push: { "server.incomeRoles": newIncome } }, (err, res) => {
|
|
if (err) return client.sendInternalError(interaction, err);
|
|
});
|
|
} else {
|
|
client.dbo.collection("guilds").updateOne({
|
|
"server.serverID": GuildDB.serverID,
|
|
"server.incomeRoles.role": incomeRoleId
|
|
},
|
|
{
|
|
$set: {
|
|
"server.incomeRoles.$.income": args[0].options[0].options[1].value
|
|
}
|
|
}, (err, res) => {
|
|
if (err) return client.sendInternalError(interaction, err);
|
|
});
|
|
}
|
|
const perform = searchIndex == -1 ? "set" : "updated";
|
|
|
|
const successIncomeRoleEmbed = new EmbedBuilder()
|
|
.setDescription(`Successfully ${perform} <@&${incomeRoleId}>"s income to $${args[0].options[0].options[1].value}`)
|
|
.setColor(client.config.Colors.Green);
|
|
|
|
return interaction.send({ embeds: [successIncomeRoleEmbed] });
|
|
|
|
} else if (args[0].options[0].name == "remove") {
|
|
const searchIndex = GuildDB.incomeRoles.findIndex((role) => role.role == incomeRoleId);
|
|
if (searchIndex == -1) {
|
|
const errorIncomeNotFoundEmbed = new EmbedBuilder()
|
|
.setDescription("**Error Notice:** Role not found")
|
|
.setColor(client.config.Colors.Red);
|
|
|
|
return interaction.send({ embeds: [errorIncomeNotFoundEmbed] });
|
|
} else {
|
|
const promptRemoveIncomeRole = new EmbedBuilder()
|
|
.setTitle(`Are you sure you want to remove this role as an income?`)
|
|
.setColor(client.config.Colors.Default)
|
|
|
|
const optRemoveIncomeRole = new ActionRowBuilder()
|
|
.addComponents(
|
|
new ButtonBuilder()
|
|
.setCustomId(`RemoveIncomeRole-yes-${incomeRoleId}-${interaction.member.user.id}`)
|
|
.setLabel("Yes")
|
|
.setStyle(ButtonStyle.Danger),
|
|
new ButtonBuilder()
|
|
.setCustomId(`RemoveIncomeRole-no-${incomeRoleId}-${interaction.member.user.id}`)
|
|
.setLabel("No")
|
|
.setStyle(ButtonStyle.Success)
|
|
)
|
|
|
|
return interaction.send({ embeds: [promptRemoveIncomeRole], components: [optRemoveIncomeRole], flags: (1 << 6) });
|
|
}
|
|
}
|
|
|
|
case "income_limiter":
|
|
client.dbo.collection("guilds").updateOne({ "server.serverID": GuildDB.serverID }, { $set: { "server.incomeLimiter": args[0].options[0].value } }, (err, res) => {
|
|
if (err) return client.sendInternalError(interaction, err);
|
|
});
|
|
|
|
let successIncomeLimiterEmbed = new EmbedBuilder()
|
|
.setColor(client.config.Colors.Green)
|
|
.setDescription(`Successfully set **${args[0].options[0].value} hours** as the wait time to collect income.`);
|
|
|
|
return interaction.send({ embeds: [successIncomeLimiterEmbed] });
|
|
|
|
case "uav-price":
|
|
client.dbo.collection("guilds").updateOne({ "server.serverID": GuildDB.serverID }, { $set: { "server.uavPrice": args[0].options[0].value } }, (err, res) => {
|
|
if (err) return client.sendInternalError(interaction, err);
|
|
});
|
|
|
|
let successUAVPriceEmbed = new EmbedBuilder()
|
|
.setColor(client.config.Colors.Green)
|
|
.setDescription(`Successfully set $${args[0].options[0].value.toFixed(2)} as UAV price`);
|
|
|
|
return interaction.send({ embeds: [successUAVPriceEmbed] });
|
|
|
|
case "emp-price":
|
|
client.dbo.collection("guilds").updateOne({ "server.serverID": GuildDB.serverID }, { $set: { "server.empPrice": args[0].options[0].value } }, (err, res) => {
|
|
if (err) return client.sendInternalError(interaction, err);
|
|
});
|
|
|
|
let successEMPPriceEmbed = new EmbedBuilder()
|
|
.setColor(client.config.Colors.Green)
|
|
.setDescription(`Successfully set $${args[0].options[0].value.toFixed(2)} as EMP price`);
|
|
|
|
return interaction.send({ embeds: [successEMPPriceEmbed] });
|
|
|
|
case "combat-log-timer":
|
|
client.dbo.collection("guilds").updateOne({ "server.serverID": GuildDB.serverID }, { $set: { "server.combatLogTimer": args[0].options[0].value } }, (err, res) => {
|
|
if (err) return client.sendInternalError(interaction, err);
|
|
});
|
|
|
|
let successCobatLogTimerEmbed = new EmbedBuilder()
|
|
.setColor(client.config.Colors.Green)
|
|
.setDescription(`Successfully set combat log timer to **${args[0].options[0].value.toFixed(0)} minutes.**`);
|
|
|
|
return interaction.send({ embeds: [successCobatLogTimerEmbed] });
|
|
|
|
case "toggle-uav-purchase":
|
|
const togggleUAVpurchase = args[0].options[0].value ? 1 : 0;
|
|
|
|
client.dbo.collection("guilds").updateOne({ "server.serverID": GuildDB.serverID }, { $set: { "server.purchaseUAV": togggleUAVpurchase } }, (err, res) => {
|
|
if (err) return client.sendInternalError(interaction, err);
|
|
});
|
|
|
|
let successToggleUAVpurchaseEmbed = new EmbedBuilder()
|
|
.setColor(client.config.Colors.Green)
|
|
.setDescription(`Users can ${togggleUAVpurchase ? "now" : "no longer"} purchase UAVs.`);
|
|
|
|
return interaction.send({ embeds: [successToggleUAVpurchaseEmbed] });
|
|
|
|
case "toggle-emp-purchase":
|
|
const togggleEMPpurchase = args[0].options[0].value ? 1 : 0;
|
|
|
|
client.dbo.collection("guilds").updateOne({ "server.serverID": GuildDB.serverID }, { $set: { "server.purchaseEMP": togggleEMPpurchase } }, (err, res) => {
|
|
if (err) return client.sendInternalError(interaction, err);
|
|
});
|
|
|
|
let successToggleEMPpurchaseEmbed = new EmbedBuilder()
|
|
.setColor(client.config.Colors.Green)
|
|
.setDescription(`Users can ${togggleUAVpurchase ? "now" : "no longer"} purchase EMPs.`);
|
|
|
|
return interaction.send({ embeds: [successToggleEMPpurchaseEmbed] });
|
|
|
|
case "killfeed":
|
|
const killfeed_configuration = args[0].options[0].name;
|
|
|
|
if (killfeed_configuration == "channel") {
|
|
|
|
const channel = args[0].options[0].options[0].value;
|
|
|
|
client.dbo.collection("guilds").updateOne({ "server.serverID": GuildDB.serverID }, { $set: { "server.killfeedChannel": channel } }, (err, res) => {
|
|
if (err) return client.sendInternalError(interaction, err);
|
|
});
|
|
|
|
const successConfigureKillfeedChannel = new EmbedBuilder()
|
|
.setColor(client.config.Colors.Green)
|
|
.setDescription(`Successfully configured the killfeed channel to <#${channel}>`);
|
|
|
|
return interaction.send({ embeds: [successConfigureKillfeedChannel] });
|
|
|
|
} else if (killfeed_configuration == "show_coords") {
|
|
const showKillfeedCoordsConfiguration = args[0].options[0].options[0].value ? 1 : 0;
|
|
|
|
client.dbo.collection("guilds").updateOne({ "server.serverID": GuildDB.serverID }, { $set: { "server.showKillfeedCoords": showKillfeedCoordsConfiguration } }, (err, res) => {
|
|
if (err) return client.sendInternalError(interaction, err);
|
|
});
|
|
|
|
const successConfigureShowKillfeedCoords = new EmbedBuilder()
|
|
.setDescription(`Successfully configured the killfeed to ${showKillfeedCoordsConfiguration ? "show" : "not show"} coordinates.`)
|
|
.setColor(client.config.Colors.Green);
|
|
|
|
return interaction.send({ embeds: [successConfigureShowKillfeedCoords] });
|
|
|
|
} else if (killfeed_configuration == "show_weapon") {
|
|
|
|
const showKillfeedWeaponConfiguration = args[0].options[0].options[0].value ? 1 : 0;
|
|
|
|
client.dbo.collection("guilds").updateOne({ "server.serverID": GuildDB.serverID }, { $set: { "server.showKillfeedWeapon": showKillfeedWeaponConfiguration } }, (err, res) => {
|
|
if (err) return client.sendInternalError(interaction, err);
|
|
});
|
|
|
|
const successConfigureShowKillfeedCoords = new EmbedBuilder()
|
|
.setDescription(`Successfully configured the killfeed to ${showKillfeedWeaponConfiguration ? "show" : "not show"} weapon icons.`)
|
|
.setColor(client.config.Colors.Green);
|
|
|
|
return interaction.send({ embeds: [successConfigureShowKillfeedCoords] });
|
|
|
|
}
|
|
|
|
case "welcome_message_server_name":
|
|
const server_name = args[0].options[0].value;
|
|
|
|
client.dbo.collection("guilds").updateOne({ "server.serverID": GuildDB.serverID }, { $set: { "server.serverName": server_name } }, (err, res) => {
|
|
if (err) return client.sendInternalError(interacion, err);
|
|
});
|
|
|
|
const succcessUpdateServerName = new EmbedBuilder()
|
|
.setDescription(`Successfully configured the server name to **${server_name}** in the welcome message.`)
|
|
.setColor(client.config.Colors.Green);
|
|
|
|
return interaction.send({ embeds: [succcessUpdateServerName] });
|
|
|
|
default:
|
|
return client.sendInternalError(interaction, "There was an error parsing the config command");
|
|
}
|
|
},
|
|
},
|
|
|
|
Interactions: {
|
|
|
|
RemoveAllowedChannels: {
|
|
run: async (client, interaction, GuildDB) => {
|
|
if (!interaction.customId.endsWith(interaction.member.user.id)) {
|
|
return interaction.reply({
|
|
content: "This button is not for you",
|
|
flags: (1 << 6)
|
|
})
|
|
}
|
|
let action = ""
|
|
if (interaction.customId.split("-")[1] == "yes") {
|
|
action = "removed";
|
|
client.dbo.collection("guilds").updateOne({ "server.serverID": GuildDB.serverID }, { $pull: { "server.allowedChannels": interaction.customId.split("-")[2] } }, (err, res) => {
|
|
if (err) return client.sendInternalError(interaction, err);
|
|
});
|
|
} else if (interaction.customId.split("-")[1] == "no") action = "kept";
|
|
|
|
const successEmbed = new EmbedBuilder()
|
|
.setColor(client.config.Colors.Green)
|
|
.setTitle(`**Success**\n> Successfullly ${action} the channel.`)
|
|
|
|
return interaction.update({ embeds: [successEmbed], components: [] });
|
|
}
|
|
},
|
|
|
|
ClearAllowedChannels: {
|
|
run: async (client, interaction, GuildDB) => {
|
|
if (!interaction.customId.endsWith(interaction.member.user.id)) {
|
|
return interaction.reply({
|
|
content: "This buttpm is not for you",
|
|
flags: (1 << 6)
|
|
});
|
|
}
|
|
let action;
|
|
if (interaction.customId.split("-")[1] == "yes") {
|
|
action = "cleared";
|
|
client.dbo.collection("guilds").updateOne({ "server.serverID": GuildDB.serverID }, { $set: { "server.allowedChannels": [] } }, (err, res) => {
|
|
if (err) return client.sendInternalError(interaction, err);
|
|
})
|
|
} else if (interaction.customId.split("-")[1] == "no") action = "kept";
|
|
|
|
const successEmbed = new EmbedBuilder()
|
|
.setColor(client.config.Colors.Green)
|
|
.setTitle(`**Success**\n> Successfully ${action} all configured channels.`);
|
|
|
|
return interaction.update({ embeds: [successEmbed], components: [] });
|
|
}
|
|
},
|
|
|
|
RemoveBotAdminRole: {
|
|
run: async (client, interaction, GuildDB) => {
|
|
if (!interaction.customId.endsWith(interaction.member.user.id)) {
|
|
return ButtonInteraction.reply({
|
|
content: "This button is not for you",
|
|
flags: (1 << 6)
|
|
})
|
|
}
|
|
let action = "";
|
|
let roleId = interaction.customId.split("-")[2];
|
|
if (interaction.customId.split("-")[1] == "yes") {
|
|
action = "removed";
|
|
client.dbo.collection("guilds").updateOne({ "server.serverID": GuildDB.serverID }, { $pull: { "server.botAdminRoles": roleId } }, (err, res) => {
|
|
if (err) return client.sendInternalError(interaction, err);
|
|
});
|
|
} else if (interaction.customId.split("-")[1] == "no") action = "kept";
|
|
|
|
const successEmbed = new EmbedBuilder()
|
|
.setColor(client.config.Colors.Green)
|
|
.setDescription(`**Successfully ${action} <@&${roleId}> as the bot admin role.**`)
|
|
|
|
return interaction.update({ embeds: [successEmbed], components: [] });
|
|
}
|
|
},
|
|
|
|
RemoveIncomeRole: {
|
|
run: async (client, interaction, GuildDB) => {
|
|
if (!interaction.customId.endsWith(interaction.member.user.id)) {
|
|
return ButtonInteraction.reply({
|
|
content: "This button is not for you",
|
|
flags: (1 << 6)
|
|
})
|
|
}
|
|
let action = "";
|
|
let roleId = interaction.customId.split("-")[2];
|
|
if (interaction.customId.split("-")[1] == "yes") {
|
|
action = "removed";
|
|
let income = GuildDB.incemeRoles.find((i) => i.role == roleId);
|
|
client.dbo.collection("guilds").updateOne({ "server.serverID": GuildDB.serverID }, { $pull: { "server.incomeRoles": income } }, (err, res) => {
|
|
if (err) return client.sendInternalError(interaction, err);
|
|
});
|
|
} else if (interaction.customId.split("-")[1] == "no") action = "kept";
|
|
|
|
const successEmbed = new EmbedBuilder()
|
|
.setColor(client.config.Colors.Green)
|
|
.setDescription(`**Successfully ${action} <@&${roleId}> as an income role.**`)
|
|
|
|
return interaction.update({ embeds: [successEmbed], components: [] });
|
|
}
|
|
},
|
|
|
|
ResetSettings: {
|
|
run: async (client, interaction, GuildDB) => {
|
|
if (!interaction.customId.endsWith(interaction.member.user.id)) {
|
|
return ButtonInteraction.reply({
|
|
content: "This button is not for you",
|
|
flags: (1 << 6)
|
|
})
|
|
}
|
|
let action = "";
|
|
if (interaction.customId.split("-")[1] == "yes") {
|
|
action = "reset";
|
|
const defaultGuildConfig = getDefaultSettings(GuildDB.serverID);
|
|
client.dbo.collection("guilds").updateOne({ "server.serverID": GuildDB.serverID }, { $set: { "server": defaultGuildConfig } }, (err, res) => {
|
|
if (err) return client.sendInternalError(interaction, err);
|
|
});
|
|
} else if (interaction.customId.split("-")[1] == "no") action = "kept";
|
|
|
|
const successEmbed = new EmbedBuilder()
|
|
.setColor(client.config.Colors.Green)
|
|
.setTitle(`Successfully ${action} guild configurations.`)
|
|
|
|
return interaction.update({ embeds: [successEmbed], components: [] });
|
|
}
|
|
}
|
|
}
|
|
} |