326 lines
12 KiB
JavaScript
326 lines
12 KiB
JavaScript
const fs = require("fs");
|
|
const Discord = require("discord.js");
|
|
const yaml = require("js-yaml");
|
|
|
|
const supportbot = yaml.load(fs.readFileSync("./Configs/supportbot.yml", "utf8"));
|
|
const cmdconfig = yaml.load(fs.readFileSync("./Configs/commands.yml", "utf8"));
|
|
const msgconfig = yaml.load(fs.readFileSync("./Configs/messages.yml", "utf8"));
|
|
|
|
const Event = require("../Structures/Event.js");
|
|
|
|
let suggestions;
|
|
try {
|
|
suggestions = require("../Data/SuggestionData.json");
|
|
} catch (error) {
|
|
suggestions = {};
|
|
}
|
|
|
|
module.exports = new Event("interactionCreate", async (client, interaction) => {
|
|
if (interaction.type == Discord.InteractionType.ApplicationCommand) {
|
|
const command = client.commands.find(
|
|
(cmd) => cmd.name.toLowerCase() === interaction.commandName
|
|
);
|
|
|
|
if (interaction.user.bot || !interaction.guild) return;
|
|
|
|
const NotValid = new Discord.EmbedBuilder()
|
|
.setDescription(`:x: \`Invalid Command\` `)
|
|
.setColor(supportbot.Embed.Colours.Error);
|
|
|
|
if (!command)
|
|
return interaction.reply({
|
|
embeds: [NotValid],
|
|
});
|
|
|
|
const permission = interaction.member.permissions.has(command.permissions);
|
|
|
|
const ValidPerms = new Discord.EmbedBuilder()
|
|
.setDescription(
|
|
"> :x: `Invalid Permissions` Do you have the correct permissions to execute this command?"
|
|
)
|
|
.setColor(supportbot.Embed.Colours.Error);
|
|
|
|
if (!permission)
|
|
return interaction.reply({
|
|
embeds: [ValidPerms],
|
|
});
|
|
command.run(interaction);
|
|
}
|
|
|
|
if (interaction.isStringSelectMenu()) {
|
|
if (interaction.customId === "ticketcontrolpanel") {
|
|
const selectedOption = interaction.values[0];
|
|
const { getRole, getChannel } = interaction.client;
|
|
switch (selectedOption) {
|
|
case "ticketadduser":
|
|
const AddUserThreadTicket = new Discord.EmbedBuilder()
|
|
.setTitle(`${msgconfig.Ticket.AddUserToTicket}`)
|
|
.setDescription(`${msgconfig.Ticket.AddUserToTicket}`)
|
|
.setColor(supportbot.Embed.Colours.General);
|
|
|
|
await interaction.reply({
|
|
embeds: [AddUserThreadTicket],
|
|
ephemeral: true,
|
|
});
|
|
break;
|
|
|
|
case "ticketremoveuser":
|
|
await removeUserFromThread(interaction);
|
|
break;
|
|
|
|
case "ticketclose":
|
|
const closeCommand = client.commands.get(cmdconfig.CloseTicket.Command);
|
|
if (closeCommand) {
|
|
closeCommand.run(interaction);
|
|
} else {
|
|
console.error("[X] Close Command Not Found");
|
|
}
|
|
break;
|
|
|
|
case "enableinvites":
|
|
await handleInvites(interaction, true);
|
|
break;
|
|
|
|
case "disableinvites":
|
|
await handleInvites(interaction, false);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (interaction.isButton()) {
|
|
if (interaction.customId === 'createticket') {
|
|
try {
|
|
const cmd = client.commands.get(cmdconfig.OpenTicket.Command);
|
|
if (!cmd) return;
|
|
cmd.run(interaction);
|
|
} catch (error) {
|
|
console.error("Error executing the ticket command:", error);
|
|
await interaction.reply({
|
|
content: "An error occurred while creating the ticket.",
|
|
ephemeral: true,
|
|
});
|
|
}
|
|
}
|
|
|
|
if (interaction.customId === "openticket") {
|
|
try {
|
|
const cmd = client.commands.get(cmdconfig.OpenTicket);
|
|
if (!cmd) return;
|
|
cmd.run(interaction);
|
|
} catch (error) {
|
|
console.error(error);
|
|
}
|
|
}
|
|
|
|
if (interaction.customId.startsWith('claimticket-')) {
|
|
const ticketChannelId = interaction.customId.split('-')[1];
|
|
const ticketChannel = interaction.guild.channels.cache.get(ticketChannelId);
|
|
if (!ticketChannel) {
|
|
return interaction.reply({
|
|
content: "Ticket channel not found.",
|
|
ephemeral: true,
|
|
});
|
|
}
|
|
|
|
const { getRole, getChannel } = interaction.client;
|
|
const Staff = await getRole(supportbot.Roles.StaffMember.Staff, interaction.guild);
|
|
const Admin = await getRole(supportbot.Roles.StaffMember.Admin, interaction.guild);
|
|
|
|
const RolePerms = new Discord.EmbedBuilder()
|
|
.setTitle("Invalid Permissions!")
|
|
.setDescription(
|
|
`${msgconfig.Error.IncorrectPerms}\n\nRole Required: \`${supportbot.Roles.StaffMember.Staff}\` or \`${supportbot.Roles.StaffMember.Admin}\``
|
|
)
|
|
.setColor(supportbot.Embed.Colours.Warn);
|
|
|
|
if (!Staff || !Admin) {
|
|
return interaction.reply({
|
|
embeds: [RolePerms],
|
|
ephemeral: true,
|
|
});
|
|
}
|
|
|
|
const NoPermsClaim = new Discord.EmbedBuilder()
|
|
.setTitle(msgconfig.Ticket.ClaimTickets.NoPermsToClaimTitle)
|
|
.setDescription(
|
|
msgconfig.Ticket.ClaimTickets.NoPermsToClaim.replace('%channel%', ticketChannel.name)
|
|
)
|
|
.setColor(supportbot.Embed.Colours.Error);
|
|
|
|
if (!interaction.member.roles.cache.has(Staff.id) && !interaction.member.roles.cache.has(Admin.id)) {
|
|
return interaction.reply({
|
|
embeds: [NoPermsClaim],
|
|
ephemeral: true,
|
|
});
|
|
}
|
|
|
|
await ticketChannel.members.add(interaction.user.id);
|
|
const pingclaimedstaff = await ticketChannel.send(`<@${interaction.user.id}>`);
|
|
|
|
setTimeout(() => {
|
|
pingclaimedstaff.delete();
|
|
}, 2000)
|
|
|
|
const TicketData = JSON.parse(fs.readFileSync("./Data/TicketData.json", "utf8"));
|
|
const ticketIndex = TicketData.tickets.findIndex((t) => t.id === ticketChannelId);
|
|
if (ticketIndex !== -1) {
|
|
TicketData.tickets[ticketIndex].claimedBy = interaction.user.id;
|
|
TicketData.tickets[ticketIndex].claimedAt = new Date().toISOString();
|
|
fs.writeFileSync("./Data/TicketData.json", JSON.stringify(TicketData, null, 4));
|
|
}
|
|
|
|
const claimMessage = await interaction.message.fetch();
|
|
const claimedEmbed = new Discord.EmbedBuilder(claimMessage.embeds[0].data)
|
|
.setTitle(msgconfig.Ticket.ClaimTickets.ClaimedTitle)
|
|
.setDescription(
|
|
msgconfig.Ticket.ClaimTickets.ClaimMessage_Edit.replace('%user%', interaction.user.id).replace('%channel%', ticketChannel.id)
|
|
)
|
|
.setColor(supportbot.Embed.Colours.Success);
|
|
|
|
const successfullyClaimed = new Discord.EmbedBuilder()
|
|
.setTitle(msgconfig.Ticket.ClaimTickets.ClaimedTitle)
|
|
.setDescription(msgconfig.Ticket.ClaimTickets.Claimed.replace('%channel%', ticketChannel.id))
|
|
.setColor(supportbot.Embed.Colours.Success);
|
|
|
|
await claimMessage.edit({ embeds: [claimedEmbed], components: [] });
|
|
await interaction.reply({
|
|
embeds: [successfullyClaimed],
|
|
ephemeral: true,
|
|
});
|
|
}
|
|
|
|
// SUGGESTION INTERACTIONS [START]
|
|
|
|
if (interaction.customId === 'upvote' || interaction.customId === 'downvote' || interaction.customId === 'removevote') {
|
|
const suggestion = suggestions[interaction.message.id];
|
|
if (!suggestion) return interaction.reply({ content: 'Suggestion not found.', ephemeral: true });
|
|
|
|
const userId = interaction.user.id;
|
|
const hasUpvoted = suggestion.upvotes.includes(userId);
|
|
const hasDownvoted = suggestion.downvotes.includes(userId);
|
|
|
|
if (interaction.customId === 'upvote') {
|
|
if (hasUpvoted) {
|
|
suggestion.upvotes = suggestion.upvotes.filter(id => id !== userId);
|
|
} else {
|
|
suggestion.upvotes.push(userId);
|
|
if (hasDownvoted) {
|
|
suggestion.downvotes = suggestion.downvotes.filter(id => id !== userId);
|
|
}
|
|
}
|
|
} else if (interaction.customId === 'downvote') {
|
|
if (hasDownvoted) {
|
|
suggestion.downvotes = suggestion.downvotes.filter(id => id !== userId);
|
|
} else {
|
|
suggestion.downvotes.push(userId);
|
|
if (hasUpvoted) {
|
|
suggestion.upvotes = suggestion.upvotes.filter(id => id !== userId);
|
|
}
|
|
}
|
|
} else if (interaction.customId === 'removevote') {
|
|
suggestion.upvotes = suggestion.upvotes.filter(id => id !== userId);
|
|
suggestion.downvotes = suggestion.downvotes.filter(id => id !== userId);
|
|
}
|
|
|
|
fs.writeFileSync("./Data/SuggestionData.json", JSON.stringify(suggestions, null, 2));
|
|
|
|
const upvoteCount = suggestion.upvotes.length;
|
|
const downvoteCount = suggestion.downvotes.length;
|
|
|
|
const updatedEmbed = new Discord.EmbedBuilder(interaction.message.embeds[0].data)
|
|
.setFields([
|
|
{ name: 'Suggestion', value: suggestion.suggestion, inline: true },
|
|
{ name: 'From', value: `<@${suggestion.author}>` },
|
|
{ name: `${supportbot.Suggestions.UpvoteEmoji} ${supportbot.Suggestions.UpvoteTitle}`, value: `${upvoteCount}`, inline: true },
|
|
{ name: `${supportbot.Suggestions.DownvoteEmoji} ${supportbot.Suggestions.DownvoteTitle}`, value: `${downvoteCount}`, inline: true }
|
|
]);
|
|
|
|
await interaction.update({ embeds: [updatedEmbed] });
|
|
}
|
|
}
|
|
|
|
async function handleInvites(interaction, enable) {
|
|
if (supportbot.Ticket.Invites.StaffOnly) {
|
|
const SupportStaff = await getRole(supportbot.Roles.StaffMember.Staff, interaction.guild);
|
|
const Admin = await getRole(supportbot.Roles.StaffMember.Admin, interaction.guild);
|
|
|
|
if (!SupportStaff || !Admin) {
|
|
return interaction.reply("Some roles seem to be missing!\nPlease check for errors when starting the bot.");
|
|
}
|
|
|
|
const NoPerms = new Discord.EmbedBuilder()
|
|
.setTitle("Invalid Permissions!")
|
|
.setDescription(
|
|
`${msgconfig.Error.IncorrectPerms}\n\nRole Required: \`${supportbot.Roles.StaffMember.Staff}\` or \`${supportbot.Roles.StaffMember.Admin}\``
|
|
)
|
|
.setColor(supportbot.Embed.Colours.Warn);
|
|
|
|
if (!interaction.member.roles.cache.has(SupportStaff.id) && !interaction.member.roles.cache.has(Admin.id)) {
|
|
return interaction.reply({ embeds: [NoPerms] });
|
|
}
|
|
}
|
|
|
|
await interaction.channel.setInvitable(enable);
|
|
|
|
const message = enable ? msgconfig.Ticket.EnableInvites : msgconfig.Ticket.DisableInvites;
|
|
const embed = new Discord.EmbedBuilder()
|
|
.setDescription(message)
|
|
.setColor(supportbot.Embed.Colours.General);
|
|
|
|
await interaction.reply({
|
|
embeds: [embed],
|
|
ephemeral: true,
|
|
});
|
|
}
|
|
|
|
// Modal submission handler for editing profile
|
|
if (interaction.type === Discord.InteractionType.ModalSubmit && interaction.customId === 'editProfileModal') {
|
|
const userId = interaction.user.id;
|
|
const profilePath = `./Data/Profiles/${userId}.json`;
|
|
|
|
let profileData;
|
|
if (fs.existsSync(profilePath)) {
|
|
profileData = JSON.parse(fs.readFileSync(profilePath, "utf8"));
|
|
} else {
|
|
profileData = {
|
|
bio: "",
|
|
timezone: "",
|
|
clockedIn: false
|
|
};
|
|
}
|
|
|
|
try {
|
|
const newBio = interaction.fields.getTextInputValue('bio');
|
|
const newTimezone = interaction.fields.getTextInputValue('timezone');
|
|
|
|
profileData.bio = newBio;
|
|
profileData.timezone = newTimezone;
|
|
|
|
fs.writeFileSync(profilePath, JSON.stringify(profileData, null, 2));
|
|
|
|
const updatedProfileEmbed = new Discord.EmbedBuilder()
|
|
.setTitle(`${interaction.user.username}'s Profile`)
|
|
.setColor(supportbot.Embed.Colours.General)
|
|
.setThumbnail(interaction.user.displayAvatarURL())
|
|
.addFields(
|
|
{ name: 'Bio', value: newBio || 'No bio set.', inline: false },
|
|
{ name: 'Timezone', value: newTimezone || 'No timezone set.', inline: true }
|
|
);
|
|
|
|
if (profileData.clockedIn !== undefined) {
|
|
updatedProfileEmbed.addFields({
|
|
name: 'Clocked In Status',
|
|
value: profileData.clockedIn ? '✅ Clocked In' : '❌ Clocked Out',
|
|
inline: true
|
|
});
|
|
}
|
|
|
|
await interaction.reply({ embeds: [updatedProfileEmbed], ephemeral: true });
|
|
} catch (error) {
|
|
console.error("Failed to update profile data: ", error);
|
|
await interaction.reply({ content: "There was an error while updating your profile. Please try again later.", ephemeral: true });
|
|
}
|
|
}
|
|
});
|