3 |
4 |
7 |
8 | 
9 |
10 |
to redeem!`, iconURL: interaction.user.displayAvatarURL() })
104 |
105 | interaction.editReply({ embeds: [embed] })
106 | },
107 | };
108 |
--------------------------------------------------------------------------------
/commands/Antinuke/Whitelist show.js:
--------------------------------------------------------------------------------
1 | const { EmbedBuilder, ApplicationCommandOptionType } = require('discord.js');
2 | const AntinukeGuildSettings = require("../../Models/Antinuke")
3 | module.exports = {
4 | name: ["antinuke", "whitelist", "show"],
5 | description: "Shows the whitelist of users for a selected antinuke category",
6 | category: "Antinuke",
7 | options: [
8 | {
9 | name: "category",
10 | description: "The category to whitelist the user for",
11 | required: true,
12 | type: ApplicationCommandOptionType.String,
13 | choices: [
14 | {
15 | name: "Owner Level",
16 | value: "owner",
17 | },
18 | {
19 | name: "AntiRole",
20 | value: "roles",
21 | },
22 | {
23 | name: "AntiChannel",
24 | value: "channels",
25 | },
26 | {
27 | name: "AntiWebhook",
28 | value: "webhooks",
29 | },
30 | {
31 | name: "AntiBot Add",
32 | value: "antibot",
33 | },
34 | {
35 | name: "AntiKick",
36 | value: "kicks",
37 | },
38 | {
39 | name: "AntiBan",
40 | value: "bans",
41 | },
42 | {
43 | name: "AntiGuild Update",
44 | value: "guildUpdate",
45 | }
46 | ],
47 | },
48 | ],
49 | permissions: {
50 | channel: [],
51 | bot: [],
52 | user: ["Administrator"]
53 | },
54 | settings: {
55 | isPremium: false,
56 | isPlayer: false,
57 | isOwner: false,
58 | inVoice: false,
59 | sameVoice: false,
60 | },
61 | run: async (interaction, client, user, language) => {
62 |
63 | await interaction.deferReply();
64 |
65 | const guildSettings = await AntinukeGuildSettings.findOne({ guildId: interaction.guild.id });
66 | if (!guildSettings) {
67 | return interaction.editReply({ content: 'Antinuke is not enabled for this guild!', ephemeral: true });
68 | }
69 |
70 |
71 |
72 | const category = interaction.options.getString('category');
73 |
74 |
75 | if(category === "owner") {
76 | const whitelist = guildSettings.ownerLevel
77 |
78 | const users = await Promise.all(
79 | whitelist.map(async (userId) => {
80 | return `<@${userId}> - \`${userId}\``;
81 | })
82 | );
83 |
84 |
85 | if (!whitelist || whitelist.length === 0) return interaction.editReply({ content: 'No users are in owner whitelist', ephemeral: true });
86 | const embed = new EmbedBuilder()
87 | .setColor(client.color)
88 | .setTitle(`Whitelisted users for Owner Level`)
89 | .setDescription(users.join('\n'));
90 |
91 | return interaction.editReply({ embeds: [embed] });
92 |
93 | } else {
94 | const whitelist = guildSettings.whitelist[category];
95 |
96 |
97 | if (!whitelist || whitelist.length === 0) {
98 | return interaction.editReply({ content: 'No users are whitelisted for this antinuke category!', ephemeral: true });
99 | }
100 |
101 | const users = await Promise.all(
102 | whitelist.map(async (userId) => {
103 | return `<@${userId}> - \`${userId}\``;
104 | })
105 | );
106 |
107 | const Anti = {
108 | roles: "AntiRole",
109 | channels: "AntiChannel ",
110 | webhooks: "AntiWebhook",
111 | kicks: "AntiKick",
112 | bans: "AntiBan",
113 | antibot: "AntiBots Add",
114 | };
115 |
116 |
117 |
118 | const embed = new EmbedBuilder()
119 | .setColor(client.color)
120 | .setTitle(`Whitelisted users for ${Anti[category]}`)
121 | .setDescription(users.join('\n'));
122 |
123 | return interaction.editReply({ embeds: [embed] });
124 | }
125 | }
126 |
127 | }
--------------------------------------------------------------------------------
/commands/Antinuke/Disable.js:
--------------------------------------------------------------------------------
1 | const { EmbedBuilder, ApplicationCommandOptionType } = require("discord.js");
2 | const GuildSettings = require("../../Models/Antinuke");
3 |
4 | module.exports = {
5 | name: ["antinuke", "disable"],
6 | description: "Disable a specific antinuke category for the guild.",
7 | category: "Antinuke",
8 | options: [
9 | {
10 | name: "category",
11 | type: ApplicationCommandOptionType.String,
12 | required: true,
13 | description: "The antinuke category to disable.",
14 | choices: [
15 | {
16 | name: "Anti All",
17 | value: "all",
18 | },
19 | {
20 | name: "AntiRole",
21 | value: "roles",
22 | },
23 | {
24 | name: "AntiChannel",
25 | value: "channels",
26 | },
27 | {
28 | name: "AntiWebhook",
29 | value: "webhooks",
30 | },
31 | {
32 | name: "AntiBot Add",
33 | value: "antibot",
34 | },
35 | {
36 | name: "AntiKick",
37 | value: "kicks",
38 | },
39 | {
40 | name: "AntiBan",
41 | value: "bans",
42 | },
43 | {
44 | name: "AntiGuild Update",
45 | value: "guildUpdate",
46 | }
47 | ],
48 | },
49 | ],
50 | permissions: {
51 | channel: [],
52 | bot: [],
53 | user: [],
54 | },
55 | settings: {
56 | isPremium: false,
57 | isPlayer: false,
58 | isOwner: false,
59 | inVoice: false,
60 | sameVoice: false,
61 | },
62 | run: async (interaction, client, user, language) => {
63 | await interaction.deferReply();
64 |
65 | if(interaction.user.id !== interaction.guild.ownerId){
66 | interaction.editReply({ content: `You Are Not Owner Of This Guild`, ephemeral: true });
67 | }
68 |
69 | const category = interaction.options.getString("category");
70 |
71 |
72 |
73 |
74 | let settings = await GuildSettings.findOne({ guildId: interaction.guild.id });
75 | if (!settings) return interaction.editReply({ content: "Antinuke Is Not Enabled In This Guild"})
76 |
77 | if (category === "all") {
78 | settings.enabled.roles = false;
79 | settings.enabled.channels = false;
80 | settings.enabled.webhooks = false;
81 | settings.enabled.kicks = false;
82 | settings.enabled.bans = false;
83 | settings.enabled.antibot = false;
84 | settings.enabled.guildUpdate = false;
85 |
86 | await settings.save();
87 |
88 | interaction.editReply({
89 | embeds: [
90 | new EmbedBuilder()
91 | .setTitle("🚩 Antinuke Settings")
92 | .setDescription(
93 | `
94 | AntiRole Create/Delete: ❌,\n
95 | AntiChannel Create/Delete: ❌,\n
96 | AntiWebhook Create/Delete: ❌\n
97 | AntiKick: ❌\n
98 | AntiBot Add: ❌\n
99 | AntiBan: ❌
100 | `
101 | )
102 | .setColor(client.color)
103 | .setFooter({
104 | text: "Tip: You Have Disabled All Antinuke Category. If Any Suspicious Activity Is Done The Bot Will Do Nothing",
105 | }),
106 | ],
107 | });
108 | } else {
109 |
110 | if(settings.enabled[category] === false) {
111 |
112 | interaction.editReply({
113 | embeds: [
114 | new EmbedBuilder()
115 | .setDescription(`That Category Is not enabled`)
116 | .setColor("Red")
117 | .setTimestamp(),
118 | ],
119 | ephemeral: true
120 | })
121 |
122 | } else {
123 |
124 | settings.enabled[category] = true;
125 | await settings.save();
126 |
127 | const Anti = {
128 | roles: "AntiRole Create/Delete",
129 | channels: "AntiChannel Create/Delete",
130 | webhooks: "AntiWebhook Create/Delete/Update",
131 | kicks: "AntiKick",
132 | bans: "AntiBan",
133 | antibot: "AntiBots Add",
134 | guildUpdate: "AntiGuild Update"
135 | };
136 |
137 | interaction.editReply({
138 | embeds: [
139 | new EmbedBuilder()
140 | .setDescription(`${Anti[category]} ❌`)
141 | .setColor(client.color),
142 | ],
143 | });
144 |
145 | }
146 | }
147 | },
148 | };
149 |
--------------------------------------------------------------------------------
/commands/Antinuke/Enable.js:
--------------------------------------------------------------------------------
1 | const { EmbedBuilder, ApplicationCommandOptionType, PermissionFlagsBits } = require("discord.js");
2 | const GuildSettings = require("../../Models/Antinuke");
3 |
4 | module.exports = {
5 | name: ["antinuke", "enable"],
6 | description: "Enables a specific antinuke category for the guild.",
7 | category: "Antinuke",
8 | options: [
9 | {
10 | name: "category",
11 | type: ApplicationCommandOptionType.String,
12 | required: true,
13 | description: "The antinuke category to enable.",
14 | choices: [
15 | {
16 | name: "Anti All",
17 | value: "all",
18 | },
19 | {
20 | name: "AntiRole",
21 | value: "roles",
22 | },
23 | {
24 | name: "AntiChannel",
25 | value: "channels",
26 | },
27 | {
28 | name: "AntiWebhook",
29 | value: "webhooks",
30 | },
31 | {
32 | name: "AntiBot Add",
33 | value: "antibot",
34 | },
35 | {
36 | name: "AntiKick",
37 | value: "kicks",
38 | },
39 | {
40 | name: "AntiBan",
41 | value: "bans",
42 | },
43 | {
44 | name: "AntiGuild Update",
45 | value: "guildUpdate",
46 | }
47 | ],
48 | },
49 | ],
50 | permissions: {
51 | channel: [],
52 | bot: [],
53 | user: [],
54 | },
55 | settings: {
56 | isPremium: false,
57 | isPlayer: false,
58 | isOwner: false,
59 | inVoice: false,
60 | sameVoice: false,
61 | },
62 | run: async (interaction, client) => {
63 | await interaction.deferReply();
64 | if(!interaction.guild.members.me.permissions.has(PermissionFlagsBits.Administrator)) interaction .channel.send({
65 | content: "**Warning**: I Don't Have Administrator Permission, Please Gimme Perms Of Administrator"
66 | })
67 |
68 | if(interaction.user.id !== interaction.guild.ownerId){
69 | interaction.editReply({ content: `You Are Not Owner Of This Guild`, ephemeral: true });
70 | }
71 |
72 | const category = interaction.options.getString("category");
73 |
74 | let settings = await GuildSettings.findOne({
75 | guildId: interaction.guild.id,
76 | });
77 | if (!settings) {
78 | settings = new GuildSettings({ guildId: interaction.guild.id });
79 | }
80 |
81 | if (category === "all") {
82 | settings.enabled.roles = true;
83 | settings.enabled.channels = true;
84 | settings.enabled.webhooks = true;
85 | settings.enabled.kicks = true;
86 | settings.enabled.bans = true;
87 | settings.enabled.antibot = true;
88 | settings.enabled.guildUpdate = true;
89 |
90 | await settings.save();
91 |
92 | interaction.editReply({
93 | embeds: [
94 | new EmbedBuilder()
95 | .setTitle("🚩 Antinuke Settings")
96 | .setDescription(
97 | `
98 | AntiRole Create/Delete: ✔️\n
99 | AntiChannel Create/Delete: ✔️\n
100 | AntiWebhook Create/Delete: ✔️\n
101 | AntiKick: ✔️\n
102 | AntiBot Add: ✔️\n
103 | AntiBan: ✔️
104 | `
105 | )
106 | .setColor(client.color)
107 | .setFooter({
108 | text: "Tip: Use `/antinuke channel` To Setup Antinuke Log Channel",
109 | }),
110 | ],
111 | });
112 | } else {
113 | if (settings.enabled[category] === true) {
114 | interaction.editReply({
115 | embeds: [
116 | new EmbedBuilder()
117 | .setColor(client.color)
118 | .setDescription(`Don't Worry That Category Is Already Enabled 😉`)
119 | .setTimestamp(),
120 | ],
121 | ephemeral: true,
122 | });
123 | } else {
124 | settings.enabled[category] = true;
125 | await settings.save();
126 |
127 | const Anti = {
128 | roles: "AntiRole",
129 | channels: "AntiChannel ",
130 | webhooks: "AntiWebhook",
131 | kicks: "AntiKick",
132 | bans: "AntiBan",
133 | antibot: "AntiBots Add",
134 | guildUpdate: "AntiGuild Update"
135 | };
136 |
137 | interaction.editReply({
138 | embeds: [
139 | new EmbedBuilder()
140 | .setDescription(`${Anti[category]} ✔️`)
141 | .setColor(client.color)
142 | .setTimestamp(),
143 | ],
144 | });
145 | }
146 | }
147 | },
148 | };
149 |
--------------------------------------------------------------------------------
/Events/Guild/interactionCreate.js:
--------------------------------------------------------------------------------
1 | const {
2 | PermissionsBitField
3 | } = require("discord.js");
4 | const chalk = require("chalk");
5 | module.exports = async (client, interaction) => {
6 | //=================================== Command Interaction =====================================\\
7 | if (
8 | interaction.isCommand ||
9 | interaction.isContextMenuCommand ||
10 | interaction.isChatInputCommand
11 | ) {
12 | if (!interaction.guild || interaction.user.bot) return;
13 |
14 | const user = client.premiums.get(interaction.user.id);
15 |
16 | let subCommandName = "";
17 | try {
18 | subCommandName = interaction.options.getSubcommand();
19 | } catch {}
20 | let subCommandGroupName = "";
21 | try {
22 | subCommandGroupName = interaction.options.getSubcommandGroup();
23 | } catch {}
24 |
25 | const command = client.slash.find((command) => {
26 | switch (command.name.length) {
27 | case 1:
28 | return command.name[0] == interaction.commandName;
29 | case 2:
30 | return (
31 | command.name[0] == interaction.commandName &&
32 | command.name[1] == subCommandName
33 | );
34 | case 3:
35 | return (
36 | command.name[0] == interaction.commandName &&
37 | command.name[1] == subCommandGroupName &&
38 | command.name[2] == subCommandName
39 | );
40 | }
41 | });
42 | if (!command) return;
43 |
44 | console.log(
45 | chalk.bgRed(
46 | `[COMMAND] ${interaction.user.tag} Used ${command.name.at(-1)} in ${
47 | interaction.guild.name
48 | } (${interaction.guild.id})`
49 | )
50 | );
51 | //check default permission (must need)
52 | if (
53 | !interaction.guild.members.me.permissions.has(
54 | PermissionsBitField.Flags.SendMessages
55 | )
56 | )
57 | return interaction.user.dmChannel.send(
58 | `I don't have permissions To \`SendMessages\``
59 | );
60 | if (
61 | !interaction.guild.members.me.permissions.has(
62 | PermissionsBitField.Flags.ViewChannel
63 | )
64 | )
65 | return;
66 | if (
67 | !interaction.guild.members.me.permissions.has(
68 | PermissionsBitField.Flags.EmbedLinks
69 | )
70 | )
71 | return interaction.reply({
72 | content: `I don't have permissions To \`EmbedLinks\``,
73 | ephemeral: true,
74 | });
75 |
76 |
77 | const { channel } = interaction.member.voice;
78 | //check in voice channel
79 | if (command.settings.inVoice) {
80 | if (!channel)
81 | return interaction.reply({
82 | content: `Command Is Set To Be In Voice Please Get In A Voice Channel`,
83 | ephemeral: true,
84 | });
85 | // check bot perms in voice channel
86 | if (
87 | !interaction.guild.members.cache
88 | .get(client.user.id)
89 | .permissionsIn(channel)
90 | .has(command.permissions.channel || [])
91 | ) {
92 | return interaction.reply({
93 | content: `I Don't have permission \`${command.permissions.bot.join(", ")}\``,
94 | ephemeral: true,
95 | });
96 | }
97 | }
98 |
99 | //check user premium
100 | if (command.settings.isPremium && !user.isPremium) {
101 | return interaction.reply({
102 | content: `This Command Is Set To Be Premium. So Buy Premium To Use This Command`,
103 | ephemeral: true,
104 | });
105 | }
106 | //check owner
107 | if (command.settings.isOwner && interaction.user.id !== client.owner) {
108 | return interaction.reply({
109 | content: `This Command Is For Owner Only`,
110 | ephemeral: true,
111 | });
112 | }
113 | //check nsfw
114 | if(command.settings.isNSFW && !interaction.channel.nsfw) {
115 | return interaction.reply({
116 | content: `This Command Can Be Use In Only NSFW channels`,
117 | ephemeral: true,
118 | });
119 | }
120 | //check bot permissions in guild
121 | if (
122 | !interaction.guild.members.me.permissions.has(
123 | command.permissions.bot || []
124 | )
125 | ) {
126 | return interaction.reply({
127 | content: `I Need ${command.permissions.bot.join(", ")} To Use This Command`,
128 | ephemeral: true,
129 | });
130 | }
131 | //check user permissions
132 | if (!interaction.member.permissions.has(command.permissions.user || [])) {
133 | return interaction.reply({
134 | content: `You Need \`${command.permissions.user.join(", ")}\``,
135 | ephemeral: true,
136 | });
137 | }
138 |
139 | if (command) {
140 | try {
141 | command.run(interaction, client);
142 | } catch (error) {
143 | await interaction.reply({
144 | content: `This Slash Command Is Not Registered And Hence Not Supported`,
145 | ephmeral: true,
146 | });
147 | }
148 | }
149 | }
150 | //=================================== Button Interaction =====================================\\
151 | // if(interaction.isButton()) {}
152 | };
153 |
--------------------------------------------------------------------------------
/commands/Antinuke/Whitelist Remove.js:
--------------------------------------------------------------------------------
1 | const { EmbedBuilder, ApplicationCommandOptionType } = require('discord.js');
2 | const GuildSettings = require("../../Models/Antinuke");
3 |
4 | module.exports = {
5 | name: ["antinuke", "whitelist", "remove"],
6 | description: "Remove a user from the whitelist for a specific antinuke category",
7 | category: "Antinuke",
8 | options: [
9 | {
10 | name: "user",
11 | description: "The user to add to the whitelist",
12 | required: true,
13 | type: ApplicationCommandOptionType.User,
14 | },
15 | {
16 | name: "category",
17 | description: "The category to whitelist the user for",
18 | required: true,
19 | type: ApplicationCommandOptionType.String,
20 | choices: [
21 | {
22 | name: "AntiRole",
23 | value: "roles",
24 | },
25 | {
26 | name: "AntiChannel",
27 | value: "channels",
28 | },
29 | {
30 | name: "AntiWebhook",
31 | value: "webhooks",
32 | },
33 | {
34 | name: "AntiBot Add",
35 | value: "antibot",
36 | },
37 | {
38 | name: "AntiKick",
39 | value: "kicks",
40 | },
41 | {
42 | name: "AntiBan",
43 | value: "bans",
44 | },
45 | {
46 | name: "AntiGuild Update",
47 | value: "guildUpdate",
48 | }
49 | ],
50 | },
51 | ],
52 | permissions: {
53 | channel: [],
54 | bot: [],
55 | user: []
56 | },
57 | settings: {
58 | isPremium: false,
59 | isPlayer: false,
60 | isOwner: false,
61 | inVoice: false,
62 | sameVoice: false,
63 | },
64 | run: async (interaction, client, user, language) => {
65 |
66 | const user1 = interaction.options.getUser('user');
67 | const category = interaction.options.getString('category');
68 | await interaction.deferReply();
69 | const ow = await GuildSettings.findOne({ guildId: interaction.guild.id });
70 | const isOwner = interaction.user.id === interaction.guild.ownerId;
71 | const isOwnerLevel = ow.ownerLevel.includes(interaction.user.id);
72 |
73 | if (!isOwner && !isOwnerLevel) {
74 | return interaction.editReply({
75 | embeds: [
76 | new EmbedBuilder()
77 | .setDescription(
78 | "‼ This Command Is Only For Guild Owner And The Users That Have Access To ownerLevel"
79 | )
80 | .setColor(client.color),
81 | ],
82 | });
83 | }
84 |
85 | const guildSettings = await GuildSettings.findOne({ guildId: interaction.guild.id });
86 | if (!guildSettings) {
87 | return interaction.editReply({ content: 'Antinuke System Not Found', ephemeral: true });
88 | }
89 |
90 | const enabled = guildSettings.enabled[category];
91 | if (!enabled) {
92 | return interaction.editReply({ content: 'Antinuke is disabled for that category.', ephemeral: true });
93 | }
94 |
95 | const whitelist = guildSettings.whitelist[category];
96 | if (!whitelist.includes(user1.id)) {
97 | return interaction.editReply({ content: 'User is not in whitelist for that category.', ephemeral: true });
98 | } else {
99 |
100 | const index = whitelist.indexOf(user1.id);
101 | if (index > -1) {
102 | whitelist.splice(index, 1);
103 | }
104 |
105 | await guildSettings.save();
106 |
107 | const logChannel = interaction.guild.channels.cache.get(guildSettings.logChannel);
108 |
109 | if (logChannel) {
110 | const Anti = {
111 | roles: "AntiRole Create/Delete",
112 | channels: "AntiChannel Create/Delete",
113 | webhooks: "AntiWebhook Create/Delete/Update",
114 | kicks: "AntiKick",
115 | bans: "AntiBan",
116 | antibot: "AntiBots Add",
117 | };
118 |
119 | logChannel.send({
120 | embeds: [
121 | new EmbedBuilder()
122 | .setColor(client.color)
123 | .setAuthor({ name: client.user.username, iconURL: client.user.displayAvatarURL()})
124 | .addFields(
125 | {
126 | name: "Category",
127 | value: `> ${Anti[category]}`,
128 | },
129 | {
130 | name: "Log Type",
131 | value: "> Whitelist Remove"
132 | },
133 | {
134 | name: "Removed By",
135 | value: `> <@${interaction.user.id}>`
136 | },
137 | {
138 | name: "User Remobed",
139 | value: `> ${user1}`
140 | }
141 | )
142 | .setFooter({ text: `© Aksh Antinuke Logs`})
143 | .setTimestamp(),
144 | ]
145 | });
146 | }
147 |
148 | interaction.editReply({
149 | content: "The user has been Removed From whitelist for that category.",
150 | ephemeral: true,
151 | });
152 |
153 |
154 |
155 |
156 |
157 | }
158 | }
159 | }
--------------------------------------------------------------------------------
/commands/Antinuke/Whitelist Add.js:
--------------------------------------------------------------------------------
1 | const { EmbedBuilder, ApplicationCommandOptionType } = require("discord.js");
2 | const GuildSettings = require("../../Models/Antinuke");
3 |
4 | module.exports = {
5 | name: ["antinuke", "whitelist", "add"],
6 | description: "Add user to the whitelist for a specific category",
7 | category: "Antinuke",
8 | options: [
9 | {
10 | name: "user",
11 | description: "The user to add to the whitelist",
12 | required: true,
13 | type: ApplicationCommandOptionType.User,
14 | },
15 | {
16 | name: "category",
17 | description: "The category to whitelist the user for",
18 | required: true,
19 | type: ApplicationCommandOptionType.String,
20 | choices: [
21 | {
22 | name: "AntiRole",
23 | value: "roles",
24 | },
25 | {
26 | name: "AntiChannel",
27 | value: "channels",
28 | },
29 | {
30 | name: "AntiWebhook",
31 | value: "webhooks",
32 | },
33 | {
34 | name: "AntiBot Add",
35 | value: "antibot",
36 | },
37 | {
38 | name: "AntiKick",
39 | value: "kicks",
40 | },
41 | {
42 | name: "AntiBan",
43 | value: "bans",
44 | },
45 | {
46 | name: "AntiGuild Update",
47 | value: "guildUpdate",
48 | },
49 | ],
50 | },
51 | ],
52 | permissions: {
53 | channel: [],
54 | bot: [],
55 | user: [],
56 | },
57 | settings: {
58 | isPremium: false,
59 | isPlayer: false,
60 | isOwner: false,
61 | inVoice: false,
62 | sameVoice: false,
63 | },
64 | run: async (interaction, client, user, language) => {
65 | await interaction.deferReply({ ephemeral: true });
66 | const ow = await GuildSettings.findOne({ guildId: interaction.guild.id });
67 | const isOwner = interaction.user.id === interaction.guild.ownerId;
68 | const isOwnerLevel = ow.ownerLevel.includes(interaction.user.id);
69 |
70 | if (!isOwner && !isOwnerLevel) {
71 | return interaction.editReply({
72 | embeds: [
73 | new EmbedBuilder()
74 | .setDescription(
75 | " This Command Is Only For Guild Owner And The Users That Have Access To ownerLevel"
76 | )
77 | .setColor(client.color),
78 | ],
79 | });
80 | }
81 |
82 | const user1 = interaction.options.getUser("user");
83 | const category = interaction.options.getString("category");
84 |
85 | const settings = await GuildSettings.findOne({
86 | guildId: interaction.guild.id,
87 | });
88 | if (!settings) {
89 | return interaction.editReply({
90 | content:
91 | "There was an error fetching the guild settings from the database. I Think You Never Used Antinuke Enable Command",
92 | ephemeral: true,
93 | });
94 | }
95 |
96 | if (!settings.enabled[category]) {
97 | return interaction.editReply({
98 | content: "Antinuke is disabled for that category.",
99 | ephemeral: true,
100 | });
101 | }
102 |
103 | if (!settings.logChannel) {
104 | return interaction.editReply({
105 | content: "Set the log channel first by using `/antinuke channel`.",
106 | ephemeral: true,
107 | });
108 | }
109 |
110 | if (settings.whitelist[category].includes(user1.id)) {
111 | return interaction.editReply({
112 | content: "The user is already whitelisted for that category.",
113 | ephemeral: true,
114 | });
115 | } else {
116 | settings.whitelist[category].push(user1.id);
117 | await settings.save();
118 |
119 | const logChannel = interaction.guild.channels.cache.get(
120 | settings.logChannel
121 | );
122 |
123 | if (logChannel) {
124 | const Anti = {
125 | roles: "AntiRole",
126 | channels: "AntiChannel ",
127 | webhooks: "AntiWebhook",
128 | kicks: "AntiKick",
129 | bans: "AntiBan",
130 | antibot: "AntiBots Add",
131 | guildUpdate: "AntiGuild Update",
132 | };
133 |
134 | logChannel.send({
135 | embeds: [
136 | new EmbedBuilder()
137 | .setColor(client.color)
138 | .setAuthor({ name: client.user.username, iconURL: client.user.displayAvatarURL()})
139 | .addFields(
140 | {
141 | name: "Category",
142 | value: `> ${Anti[category]}`,
143 | },
144 | {
145 | name: "Log Type",
146 | value: "> Whitelist Add"
147 | },
148 | {
149 | name: "Added By",
150 | value: `> <@${interaction.user.id}>`
151 | },
152 | {
153 | name: "User Added",
154 | value: `> ${user1}`
155 | }
156 | )
157 | .setFooter({ text: `© Aksh Antinuke Logs`})
158 | .setTimestamp(),
159 | ]
160 | });
161 | }
162 |
163 | interaction.editReply({
164 | content: "The user has been added to the whitelist for that category.",
165 | ephemeral: true,
166 | });
167 | }
168 | },
169 | };
170 |
--------------------------------------------------------------------------------
/deploySlash.js:
--------------------------------------------------------------------------------
1 | const { plsParseArgs } = require('plsargs');
2 | const args = plsParseArgs(process.argv.slice(2));
3 | const chillout = require("chillout");
4 | const { makeSureFolderExists } = require("stuffs");
5 | const path = require("path");
6 | const readdirRecursive = require("recursive-readdir");
7 | const { TOKEN } = require("./Settings/config.js");
8 | const { ApplicationCommandOptionType, REST, Routes, ApplicationCommandManager } = require('discord.js');
9 |
10 | (async () => {
11 |
12 | let command = [];
13 |
14 | let cleared = args.get(0) == "guild" ? args.get(2) == "clear" : (args.get(0) == "global" ? args.get(1) == "clear" : false);
15 | let deployed = args.get(0) == "guild" ? "guild" : args.get(0) == "global" ? "global" : null;
16 |
17 | if (!deployed) {
18 | console.error(`Invalid sharing mode! Valid modes: guild, global`);
19 | console.error(`Usage example: node deploySlash.js guild [clear]`);
20 | console.error(`Usage example: node deploySlash.js global [clear]`);
21 | return process.exit(1);
22 | }
23 |
24 | if (!cleared) {
25 | let interactionsFolder = path.resolve("./commands");
26 |
27 | await makeSureFolderExists(interactionsFolder);
28 |
29 | let store = [];
30 |
31 | console.log("Reading interaction files..")
32 |
33 | let interactionFilePaths = await readdirRecursive(interactionsFolder);
34 | interactionFilePaths = interactionFilePaths.filter(i => {
35 | let state = path.basename(i).startsWith("-");
36 | return !state;
37 | });
38 |
39 | await chillout.forEach(interactionFilePaths, (interactionFilePath) => {
40 | const cmd = require(interactionFilePath);
41 | console.log(`Interaction "${cmd.type == "CHAT_INPUT" ? `/${cmd.name.join(" ")}` : `${cmd.name[0]}`}" ${cmd.name[1] || ""} ${cmd.name[2] || ""} added to the transform list!`);
42 | store.push(cmd);
43 | });
44 |
45 | store = store.sort((a, b) => a.name.length - b.name.length)
46 |
47 | command = store.reduce((all, current) => {
48 | switch (current.name.length) {
49 | case 1: {
50 | all.push({
51 | type: current.type,
52 | name: current.name[0],
53 | description: current.description,
54 | defaultPermission: current.defaultPermission,
55 | options: current.options
56 | });
57 | break;
58 | }
59 | case 2: {
60 | let baseItem = all.find((i) => {
61 | return i.name == current.name[0] && i.type == current.type
62 | });
63 | if (!baseItem) {
64 | all.push({
65 | type: current.type,
66 | name: current.name[0],
67 | description: `${current.name[0]} commands.`,
68 | defaultPermission: current.defaultPermission,
69 | options: [
70 | {
71 | type: ApplicationCommandOptionType.Subcommand,
72 | description: current.description,
73 | name: current.name[1],
74 | options: current.options
75 | }
76 | ]
77 | });
78 | } else {
79 | baseItem.options.push({
80 | type: ApplicationCommandOptionType.Subcommand,
81 | description: current.description,
82 | name: current.name[1],
83 | options: current.options
84 | })
85 | }
86 | break;
87 | }
88 | case 3: {
89 | let SubItem = all.find((i) => {
90 | return i.name == current.name[0] && i.type == current.type
91 | });
92 | if (!SubItem) {
93 | all.push({
94 | type: current.type,
95 | name: current.name[0],
96 | description: `${current.name[0]} commands.`,
97 | defaultPermission: current.defaultPermission,
98 | options: [
99 | {
100 | type: ApplicationCommandOptionType.SubcommandGroup,
101 | description: `${current.name[1]} commands.`,
102 | name: current.name[1],
103 | options: [
104 | {
105 | type: ApplicationCommandOptionType.Subcommand,
106 | description: current.description,
107 | name: current.name[2],
108 | options: current.options
109 | }
110 | ]
111 | }
112 | ]
113 | });
114 | } else {
115 | let GroupItem = SubItem.options.find(i => {
116 | return i.name == current.name[1] && i.type == ApplicationCommandOptionType.SubcommandGroup
117 | });
118 | if (!GroupItem) {
119 | SubItem.options.push({
120 | type: ApplicationCommandOptionType.SubcommandGroup,
121 | description: `${current.name[1]} commands.`,
122 | name: current.name[1],
123 | options: [
124 | {
125 | type: ApplicationCommandOptionType.Subcommand,
126 | description: current.description,
127 | name: current.name[2],
128 | options: current.options
129 | }
130 | ]
131 | })
132 | } else {
133 | GroupItem.options.push({
134 | type: ApplicationCommandOptionType.Subcommand,
135 | description: current.description,
136 | name: current.name[2],
137 | options: current.options
138 | })
139 | }
140 | }
141 | }
142 | break;
143 | }
144 |
145 | return all;
146 | }, []);
147 |
148 | command = command.map(i => ApplicationCommandManager.transformCommand(i));
149 | } else {
150 | console.info("No interactions read, all existing ones will be cleared...");
151 | }
152 |
153 | const rest = new REST({ version: "9" }).setToken(TOKEN);
154 | const client = await rest.get(Routes.user());
155 | console.info(`Account information received! ${client.username}#${client.discriminator} (${client.id})`);
156 |
157 | console.info(`Interactions are posted on discord!`);
158 | switch (deployed) {
159 | case "guild": {
160 | let guildId = args.get(1);
161 | console.info(`Deploy mode: guild (${guildId})`);
162 |
163 | await rest.put(Routes.applicationGuildCommands(client.id, guildId), { body: command });
164 |
165 | console.info(`Shared commands may take 3-5 seconds to arrive.`);
166 | break;
167 | }
168 | case "global": {
169 | console.info(`Deploy mode: global`);
170 |
171 | await rest.put(Routes.applicationCommands(client.id), { body: command });
172 |
173 | console.info(`Shared commands can take up to 1 hour to arrive. If you want it to come immediately, you can throw your bot from your server and get it back.`);
174 | break;
175 | }
176 | }
177 |
178 | console.info(`Interactions shared!`);
179 | })();
180 |
181 | /// Credit https://github.com/akanora/Youtube-Together (Handler) || Edit by: https://github.com/Adivise
--------------------------------------------------------------------------------
/Handler/Antinuke.js:
--------------------------------------------------------------------------------
1 | const { EmbedBuilder, AuditLogEvent, PermissionFlagsBits } = require("discord.js");
2 | const GuildSettings = require("../../Models/Antinuke");
3 |
4 | module.exports = (client) => {
5 | //=================================== Anti Channel Events ===================================//
6 | client.on("channelCreate", async (channel) => {
7 | if(!channel.guild.members.me.permissions.has(PermissionFlagsBits.ViewAuditLog)) return;
8 | const auditlogs = await channel.guild.fetchAuditLogs({
9 | type: AuditLogEvent.ChannelCreate,
10 | limit: 1,
11 | });
12 | const logs = auditlogs.entries.first();
13 | if(!logs) return;
14 | const { executor } = logs;
15 |
16 | await GuildSettings.findOne(
17 | { guildId: channel.guild.id },
18 | async (err, data) => {
19 | if(!data) return;
20 | const antinuke = data.enabled.channels;
21 | const trusted = data.whitelist.channels.includes(executor.id);
22 | const owner = data.ownerLevel.includes(executor.id);
23 |
24 | if (executor.id === channel.guild.ownerId) return;
25 | if (executor.id === client.user.id) return;
26 | if (antinuke === false) return;
27 | if (trusted === true) return;
28 | if (owner === true) return;
29 |
30 | channel.delete();
31 | const member = await channel.guild.members.fetch(executor.id);
32 | member.ban({ reason: "© Nityam Anti Channel Create" });
33 |
34 | const logChannel = channel.guild.channels.cache.get(data.logChannel);
35 | if (logChannel) {
36 | logChannel.send({
37 | embeds: [
38 | new EmbedBuilder()
39 | .setColor(client.color)
40 | .setAuthor({
41 | name: client.user.username,
42 | iconURL: client.user.displayAvatarURL(),
43 | })
44 | .addFields(
45 | {
46 | name: "Category",
47 | value: `> Anti Channel Create`,
48 | },
49 | {
50 | name: "Log Type",
51 | value: "> User Banned",
52 | },
53 | {
54 | name: "User",
55 | value: `> ${executor} ${executor.id}`,
56 | },
57 | {
58 | name: "Reason",
59 | value: `> Creating Channels`,
60 | }
61 | )
62 | .setFooter({ text: `© Nityam Antinuke Logs` })
63 | .setTimestamp(),
64 | ],
65 | });
66 | }
67 | }
68 | );
69 | });
70 |
71 | client.on("channelDelete", async (channel) => {
72 | if(!channel.guild.members.me.permissions.has(PermissionFlagsBits.ViewAuditLog)) return;
73 | const auditlogs = await channel.guild.fetchAuditLogs({
74 | type: AuditLogEvent.ChannelDelete,
75 | limit: 1,
76 | });
77 | const logs = auditlogs.entries.first();
78 | if(!logs) return;
79 | const { executor } = logs;
80 |
81 | await GuildSettings.findOne(
82 | { guildId: channel.guild.id },
83 | async (err, data) => {
84 | if(!data) return;
85 | const antinuke = data.enabled.channels;
86 | const trusted = data.whitelist.channels.includes(executor.id);
87 | const owner = data.ownerLevel.includes(executor.id);
88 |
89 | if (executor.id === channel.guild.ownerId) return;
90 | if (executor.id === client.user.id) return;
91 | if (antinuke === false) return;
92 | if (trusted === true) return;
93 | if (owner === true) return;
94 |
95 | channel.clone();
96 |
97 | const member = await channel.guild.members.fetch(executor.id);
98 | member.ban({ reason: "© Nityam Anti Channel Delete" });
99 |
100 | const logChannel = channel.guild.channels.cache.get(data.logChannel);
101 | if (logChannel) {
102 | logChannel.send({
103 | embeds: [
104 | new EmbedBuilder()
105 | .setColor(client.color)
106 | .setAuthor({
107 | name: client.user.username,
108 | iconURL: client.user.displayAvatarURL(),
109 | })
110 | .addFields(
111 | {
112 | name: "Category",
113 | value: `> Anti Channel Delete`,
114 | },
115 | {
116 | name: "Log Type",
117 | value: "> User Banned",
118 | },
119 | {
120 | name: "User",
121 | value: `> ${executor} ${executor.id}`,
122 | },
123 | {
124 | name: "Reason",
125 | value: `> Deleting Channels`,
126 | }
127 | )
128 | .setFooter({ text: `© Nityam Antinuke Logs` })
129 | .setTimestamp(),
130 | ],
131 | });
132 | }
133 | }
134 | );
135 | });
136 |
137 | client.on("channelUpdate", async (o, n) => {
138 | if(!n.guild.members.me.permissions.has(PermissionFlagsBits.ViewAuditLog)) return;
139 | const auditlogs = await n.guild.fetchAuditLogs({
140 | type: AuditLogEvent.ChannelUpdate,
141 | limit: 1,
142 | });
143 | const logs = auditlogs.entries.first();
144 | if(!logs) return;
145 | const { executor } = logs;
146 |
147 | await GuildSettings.findOne({ guildId: o.guild.id }, async (err, data) => {
148 | if(!data) return;
149 | const antinuke = data.enabled.channels;
150 | const trusted = data.whitelist.channels.includes(executor.id);
151 | const owner = data.ownerLevel.includes(executor.id);
152 |
153 | if (executor.id === o.guild.ownerId) return;
154 | if (executor.id === client.user.id) return;
155 | if (antinuke === false) return;
156 | if (trusted === true) return;
157 | if (owner === true) return;
158 |
159 | const oldName = o.name;
160 | const newName = n.name;
161 |
162 | const member = await n.guild.members.fetch(executor.id);
163 | member.ban({ reason: "© Nityam Anti Channel Update" });
164 |
165 | const logChannel = channel.guild.channels.cache.get(data.logChannel);
166 | if (logChannel) {
167 | logChannel.send({
168 | embeds: [
169 | new EmbedBuilder()
170 | .setColor(client.color)
171 | .setAuthor({
172 | name: client.user.username,
173 | iconURL: client.user.displayAvatarURL(),
174 | })
175 | .addFields(
176 | {
177 | name: "Category",
178 | value: `> Anti Channel Update`,
179 | },
180 | {
181 | name: "Log Type",
182 | value: "> User Banned",
183 | },
184 | {
185 | name: "User",
186 | value: `> ${executor} ${executor.id}`,
187 | },
188 | {
189 | name: "Reason",
190 | value: `> Updating Channels`,
191 | }
192 | )
193 | .setFooter({ text: `© Nityam Antinuke Logs` })
194 | .setTimestamp(),
195 | ],
196 | });
197 | }
198 |
199 | if (oldName !== newName) {
200 | await n.edit({
201 | name: oldName,
202 | });
203 | }
204 | if (n.isText()) {
205 | const oldTopic = o.topic;
206 | const newTopic = n.topic;
207 | if (oldTopic !== newTopic) {
208 | await n.setTopic(oldTopic);
209 | }
210 | }
211 | });
212 | });
213 |
214 | //=================================== Anti Role Events ===================================//
215 |
216 | client.on("roleCreate", async (role) => {
217 | if(!role.guild.members.me.permissions.has(PermissionFlagsBits.ViewAuditLog)) return;
218 | const auditlogs = await role.guild.fetchAuditLogs({
219 | type: AuditLogEvent.RoleCreate,
220 | limit: 1,
221 | });
222 | const logs = auditlogs.entries.first();
223 | if(!logs) return;
224 | const { executor } = logs;
225 |
226 | await GuildSettings.findOne(
227 | { guildId: role.guild.id },
228 | async (err, data) => {
229 | if(!data) return;
230 | const antinuke = data.enabled.roles;
231 | const trusted = data.whitelist.roles.includes(executor.id);
232 | const owner = data.ownerLevel.includes(executor.id);
233 |
234 | if (executor.id === role.guild.ownerId) return;
235 | if (executor.id === client.user.id) return;
236 | if (antinuke === false) return;
237 | if (trusted === true) return;
238 | if (owner === true) return;
239 |
240 | role.delete();
241 | const member = await role.guild.members.fetch(executor.id);
242 | member.ban({ reason: "© Nityam Anti Role Create" });
243 |
244 | const logChannel = role.guild.channels.cache.get(data.logChannel);
245 | if (logChannel) {
246 | logChannel.send({
247 | embeds: [
248 | new EmbedBuilder()
249 | .setColor(client.color)
250 | .setAuthor({
251 | name: client.user.username,
252 | iconURL: client.user.displayAvatarURL(),
253 | })
254 | .addFields(
255 | {
256 | name: "Category",
257 | value: `> Anti Role Create`,
258 | },
259 | {
260 | name: "Log Type",
261 | value: "> User Banned",
262 | },
263 | {
264 | name: "User",
265 | value: `> ${executor} ${executor.id}`,
266 | },
267 | {
268 | name: "Reason",
269 | value: `> Creating Roles`,
270 | }
271 | )
272 | .setFooter({ text: `© Nityam Antinuke Logs` })
273 | .setTimestamp(),
274 | ],
275 | });
276 | }
277 | }
278 | );
279 | });
280 |
281 | client.on("roleUpdate", async (o, n) => {
282 | if(!n.guild.members.me.permissions.has(PermissionFlagsBits.ViewAuditLog)) return;
283 | const auditlogs = await n.guild.fetchAuditLogs({
284 | type: AuditLogEvent.RoleUpdate,
285 | limit: 1,
286 | });
287 | const logs = auditlogs.entries.first();
288 | if(!logs) return;
289 | const { executor } = logs;
290 |
291 | await GuildSettings.findOne({ guildId: o.guild.id }, async (err, data) => {
292 | if(!data) return;
293 | const antinuke = data.enabled.roles;
294 | const trusted = data.whitelist.roles.includes(executor.id);
295 | const owner = data.ownerLevel.includes(executor.id);
296 |
297 | if (executor.id === n.guild.ownerId) return;
298 | if (executor.id === client.user.id) return;
299 | if (antinuke === false) return;
300 | if (trusted === true) return;
301 | if (owner === true) return;
302 |
303 | n.setPermissions(o.permissions);
304 | const member = await n.guild.members.fetch(executor.id);
305 | member.ban({ reason: "© Nityam Anti Role Update" });
306 |
307 | const logChannel = role.guild.channels.cache.get(data.logChannel);
308 | if (logChannel) {
309 | logChannel.send({
310 | embeds: [
311 | new EmbedBuilder()
312 | .setColor(client.color)
313 | .setAuthor({
314 | name: client.user.username,
315 | iconURL: client.user.displayAvatarURL(),
316 | })
317 | .addFields(
318 | {
319 | name: "Category",
320 | value: `> Anti Role Update`,
321 | },
322 | {
323 | name: "Log Type",
324 | value: "> User Banned",
325 | },
326 | {
327 | name: "User",
328 | value: `> ${executor} ${executor.id}`,
329 | },
330 | {
331 | name: "Reason",
332 | value: `> Updating Roles`,
333 | }
334 | )
335 | .setFooter({ text: `© Nityam Antinuke Logs` })
336 | .setTimestamp(),
337 | ],
338 | });
339 | }
340 | });
341 | });
342 |
343 | client.on("roleDelete", async (role) => {
344 | if(!role.guild.members.me.permissions.has(PermissionFlagsBits.ViewAuditLog)) return;
345 | const auditlogs = await role.guild.fetchAuditLogs({
346 | type: AuditLogEvent.RoleDelete,
347 | limit: 1,
348 | });
349 | const logs = auditlogs.entries.first();
350 | if(!logs) return;
351 | const { executor } = logs;
352 |
353 | await GuildSettings.findOne(
354 | { guildId: role.guild.id },
355 | async (err, data) => {
356 | if(!data) return;
357 | const antinuke = data.enabled.roles;
358 | const trusted = data.whitelist.roles.includes(executor.id);
359 | const owner = data.ownerLevel.includes(executor.id);
360 |
361 | if (executor.id === role.guild.ownerId) return;
362 | if (executor.id === client.user.id) return;
363 | if (antinuke === false) return;
364 | if (trusted === true) return;
365 | if (owner === true) return;
366 | if (role.managed) return;
367 |
368 | role.guild.roles.create({ name: role.name, color: role.color });
369 | const member = await role.guild.members.fetch(executor.id);
370 | member.ban({ reason: "© Nityam Anti Role Delete" });
371 |
372 | const logChannel = role.guild.channels.cache.get(data.logChannel);
373 | if (logChannel) {
374 | logChannel.send({
375 | embeds: [
376 | new EmbedBuilder()
377 | .setColor(client.color)
378 | .setAuthor({
379 | name: client.user.username,
380 | iconURL: client.user.displayAvatarURL(),
381 | })
382 | .addFields(
383 | {
384 | name: "Category",
385 | value: `> Anti Role Delete`,
386 | },
387 | {
388 | name: "Log Type",
389 | value: "> User Banned",
390 | },
391 | {
392 | name: "User",
393 | value: `> ${executor} ${executor.id}`,
394 | },
395 | {
396 | name: "Reason",
397 | value: `> Deleting Roles`,
398 | }
399 | )
400 | .setFooter({ text: `© Nityam Antinuke Logs` })
401 | .setTimestamp(),
402 | ],
403 | });
404 | }
405 | }
406 | );
407 | });
408 |
409 | //=================================== Anti Member Events ===================================//
410 | client.on("guildMemberUpdate", async (o, n) => {
411 | if(!n.guild.members.me.permissions.has(PermissionFlagsBits.ViewAuditLog)) return;
412 | const auditLogs = await n.guild.fetchAuditLogs({
413 | limit: 1,
414 | type: AuditLogEvent.MemberRoleUpdate,
415 | });
416 | const logs = auditLogs.entries.first();
417 | if(!logs) return;
418 | const { executor, target } = logs;
419 |
420 | await GuildSettings.findOne({ guildId: o.guild.id }, async (err, data) => {
421 |
422 | if(!data) return;
423 | const antinuke = data.enabled.roles;
424 | const trusted = data.whitelist.roles.includes(executor.id);
425 | const owner = data.ownerLevel.includes(executor.id);
426 |
427 | if (antinuke === false) return;
428 | if (trusted === true) return;
429 | if (owner === true) return;
430 | if (executor.id === client.user.id) return;
431 | if (executor.id === n.guild.ownerId) return;
432 |
433 | const oldRoles = o.roles;
434 | const newRoles = n.roles;
435 |
436 | if (oldRoles !== newRoles) {
437 | n.roles.set(o.roles.cache);
438 | }
439 |
440 | const member = await n.guild.members.fetch(executor.id);
441 | member.ban({ reason: "© Nityam Anti Member Role Update" });
442 |
443 | const logChannel = role.guild.channels.cache.get(data.logChannel);
444 | if (logChannel) {
445 | logChannel.send({
446 | embeds: [
447 | new EmbedBuilder()
448 | .setColor(client.color)
449 | .setAuthor({
450 | name: client.user.username,
451 | iconURL: client.user.displayAvatarURL(),
452 | })
453 | .addFields(
454 | {
455 | name: "Category",
456 | value: `> Anti Member Role Update`,
457 | },
458 | {
459 | name: "Log Type",
460 | value: "> User Banned",
461 | },
462 | {
463 | name: "User",
464 | value: `> ${executor} ${executor.id}`,
465 | },
466 | {
467 | name: "Reason",
468 | value: `> Updating Member Roles`,
469 | }
470 | )
471 | .setFooter({ text: `© Nityam Antinuke Logs` })
472 | .setTimestamp(),
473 | ],
474 | });
475 | }
476 | });
477 | });
478 |
479 | //=================================== Anti Ban Events ===================================//
480 | client.on("guildBanAdd", async (member) => {
481 | if(!member.guild.members.me.permissions.has(PermissionFlagsBits.ViewAuditLog)) return;
482 | const auditLogs = await member.guild.fetchAuditLogs({
483 | type: AuditLogEvent.MemberBanAdd,
484 | limit: 1,
485 | });
486 | const logs = auditLogs.entries.first();
487 | if(!logs) return;
488 | const { executor, target } = logs;
489 |
490 | await GuildSettings.findOne(
491 | { guildId: member.guild.id },
492 | async (err, data) => {
493 | if(!data) return;
494 | const antinuke = data.enabled.bans;
495 | const trusted = data.whitelist.bans.includes(executor.id);
496 | const owner = data.ownerLevel.includes(executor.id);
497 |
498 | if (antinuke === false) return;
499 | if (trusted === true) return;
500 | if (member.id !== target.id) return;
501 | if (owner === true) return;
502 | if (executor.id === client.user.id) return;
503 | if (executor.id === member.guild.ownerId) return;
504 |
505 | const member2 = member.guild.members.fetch(executor.id);
506 | member2.ban({ reason: "© Nityam Anti Member Ban " });
507 |
508 | const logChannel = member.guild.channels.cache.get(data.logChannel);
509 | if (logChannel) {
510 | logChannel.send({
511 | embeds: [
512 | new EmbedBuilder()
513 | .setColor(client.color)
514 | .setAuthor({
515 | name: client.user.username,
516 | iconURL: client.user.displayAvatarURL(),
517 | })
518 | .addFields(
519 | {
520 | name: "Category",
521 | value: `> Anti Member Ban`,
522 | },
523 | {
524 | name: "Log Type",
525 | value: "> User Banned",
526 | },
527 | {
528 | name: "User",
529 | value: `> ${executor} ${executor.id}`,
530 | },
531 | {
532 | name: "Reason",
533 | value: "> Baning Members",
534 | },
535 | {
536 | name: "Target",
537 | value: `> ${target} ${target.id}`,
538 | }
539 | )
540 | .setFooter({ text: `© Nityam Antinuke Logs` })
541 | .setTimestamp(),
542 | ],
543 | });
544 | }
545 | }
546 | );
547 | });
548 |
549 | //=================================== Anti Kick Events ===================================//
550 | client.on("guildMemberRemove", async (member) => {
551 | if(!member.guild.members.me.permissions.has(PermissionFlagsBits.ViewAuditLog)) return;
552 | const auditLogs = await member.guild.fetchAuditLogs({
553 | type: AuditLogEvent.MemberKick,
554 | limit: 1,
555 | });
556 | const logs = auditLogs.entries.first();
557 | if(!logs) return;
558 | const { executor, target } = logs;
559 |
560 | await GuildSettings.findOne(
561 | { guildId: member.guild.id },
562 | async (err, data) => {
563 | if(!data) return;
564 | const antinuke = data.enabled.kicks;
565 | const trusted = data.whitelist.kicks.includes(executor.id);
566 | const owner = data.ownerLevel.includes(executor.id);
567 |
568 | if (executor.id === client.user.id) return;
569 | if (executor.id === member.guild.ownerId) return;
570 | if (antinuke === false) return;
571 | if (member.id !== target.id) return;
572 | if (trusted === true) return;
573 | if (owner === true) return;
574 |
575 | const member2 = member.guild.members.fetch(executor.id);
576 | member2.ban({ reason: "© Nityam Anti Member Kick " });
577 |
578 | const logChannel = member.guild.channels.cache.get(data.logChannel);
579 | if (logChannel) {
580 | logChannel.send({
581 | embeds: [
582 | new EmbedBuilder()
583 | .setColor(client.color)
584 | .setAuthor({
585 | name: client.user.username,
586 | iconURL: client.user.displayAvatarURL(),
587 | })
588 | .addFields(
589 | {
590 | name: "Category",
591 | value: `> Anti Member Kick`,
592 | },
593 | {
594 | name: "Log Type",
595 | value: "> User Banned",
596 | },
597 | {
598 | name: "User",
599 | value: `> ${executor} ${executor.id}`,
600 | },
601 | {
602 | name: "Reason",
603 | value: "> Kicking Members",
604 | },
605 | {
606 | name: "Target",
607 | value: `> ${target} ${target.id}`,
608 | }
609 | )
610 | .setFooter({ text: `© Nityam Antinuke Logs` })
611 | .setTimestamp(),
612 | ],
613 | });
614 | }
615 | }
616 | );
617 | });
618 |
619 | //=================================== Anti Bot Events ===================================//
620 | client.on("guildMemberAdd", async (member) => {
621 | if(!member.guild.members.me.permissions.has(PermissionFlagsBits.ViewAuditLog)) return;
622 | const auditLogs = await member.guild.fetchAuditLogs({
623 | type: AuditLogEvent.BotAdd,
624 | limit: 1,
625 | });
626 | const logs = auditLogs.entries.first();
627 | if(!logs) return;
628 | const { executor, target } = logs;
629 |
630 | await GuildSettings.findOne(
631 | { guildId: member.guild.id },
632 | async (err, data) => {
633 | if(!data) return;
634 | const antinuke = data.enabled.antibot;
635 | const trusted = data.whitelist.antibot.includes(executor.id);
636 | const owner = data.ownerLevel.includes(executor.id);
637 |
638 | if (executor.id === client.user.id) return;
639 | if (executor.id === member.guild.ownerId) return;
640 | if (antinuke === false) return;
641 | if (trusted === true) return;
642 | if (!target.bot) return;
643 | if (owner === true) return;
644 | if (target.id !== member.id) return;
645 |
646 | const member3 = member.guild.members.fetch(executor.id);
647 | member3.ban({ reason: "© Nityam Anti Bot Add " });
648 | const member2 = member.guild.members.fetch(target.id);
649 | member2.ban({ reason: "© Nityam Anti Bot Add " });
650 |
651 | const logChannel = member.guild.channels.cache.get(data.logChannel);
652 | if (logChannel) {
653 | logChannel.send({
654 | embeds: [
655 | new EmbedBuilder()
656 | .setColor(client.color)
657 | .setAuthor({
658 | name: client.user.username,
659 | iconURL: client.user.displayAvatarURL(),
660 | })
661 | .addFields(
662 | {
663 | name: "Category",
664 | value: `> Anti Bot Add`,
665 | },
666 | {
667 | name: "Log Type",
668 | value: "> User Banned",
669 | },
670 | {
671 | name: "User",
672 | value: `> ${executor} ${executor.id}`,
673 | },
674 | {
675 | name: "Reason",
676 | value: "> Illegal Bot Add",
677 | },
678 | {
679 | name: "Bot",
680 | value: `> ${target} ${target.id}`,
681 | }
682 | )
683 | .setFooter({ text: `© Nityam Antinuke Logs` })
684 | .setTimestamp(),
685 | ],
686 | });
687 | }
688 | }
689 | );
690 | });
691 |
692 | //=================================== Anti Webhook Events ===================================//
693 |
694 | client.on("webhookUpdate", async (webhook) => {
695 | if(!webhook.guild.members.me.permissions.has(PermissionFlagsBits.ViewAuditLog)) return;
696 | const auditLog = await webhook.guild.fetchAuditLogs({
697 | limit: 1,
698 | type: AuditLogEvent.WebhookUpdate,
699 | });
700 | const logs = auditLog.entries.first();
701 | if(!logs) return;
702 | const { executor } = logs;
703 |
704 | await GuildSettings.findOne(
705 | { guildId: webhook.guild.id },
706 | async (err, data) => {
707 | if(!data) return;
708 | const antinuke = data.enabled.webhooks;
709 | const trusted = data.whitelist.webhooks.includes(executor.id);
710 | const owner = data.ownerLevel.includes(executor.id);
711 |
712 | if (antinuke === false) return;
713 | if (trusted === true) return;
714 | if (owner === true) return;
715 | if (executor.id === client.user.id) return;
716 | if (executor.id === webhook.guild.ownerId) return;
717 |
718 | const member = webhook.guild.members.fetch(executor.id);
719 | member.ban({ reason: "© Nityam Anti Webhook Update" });
720 |
721 | const logChannel = webhook.guild.channels.cache.get(data.logChannel);
722 | if (logChannel) {
723 | logChannel.send({
724 | embeds: [
725 | new EmbedBuilder()
726 | .setColor(client.color)
727 | .setAuthor({
728 | name: client.user.username,
729 | iconURL: client.user.displayAvatarURL(),
730 | })
731 | .addFields(
732 | {
733 | name: "Category",
734 | value: `> Anti Webhook Update`,
735 | },
736 | {
737 | name: "Log Type",
738 | value: "> User Banned",
739 | },
740 | {
741 | name: "User",
742 | value: `> ${executor} ${executor.id}`,
743 | },
744 | {
745 | name: "Reason",
746 | value: "> Updating Webhook",
747 | }
748 | )
749 | .setFooter({ text: `© Nityam Antinuke Logs` })
750 | .setTimestamp(),
751 | ],
752 | });
753 | }
754 | }
755 | );
756 | });
757 |
758 | client.on("webhookUpdate", async (webhook) => {
759 | if(!webhook.guild.members.me.permissions.has(PermissionFlagsBits.ViewAuditLog)) return;
760 | const auditLog = await webhook.guild.fetchAuditLogs({
761 | limit: 1,
762 | type: AuditLogEvent.WebhookCreate,
763 | });
764 | const logs = auditLog.entries.first();
765 | if(!logs) return;
766 | const { executor } = logs;
767 |
768 | await GuildSettings.findOne(
769 | { guildId: webhook.guild.id },
770 | async (err, data) => {
771 | if(!data) return;
772 | const antinuke = data.enabled.webhooks;
773 | const trusted = data.whitelist.webhooks.includes(executor.id);
774 | const owner = data.ownerLevel.includes(executor.id);
775 |
776 | if (antinuke === false) return;
777 | if (trusted === true) return;
778 | if (owner === true) return;
779 | if (executor.id === client.user.id) return;
780 | if (executor.id === webhook.guild.ownerId) return;
781 |
782 | const member = webhook.guild.members.fetch(executor.id);
783 | member.ban({ reason: "© Nityam Anti Webhook Create" });
784 |
785 | const logChannel = webhook.guild.channels.cache.get(data.logChannel);
786 | if (logChannel) {
787 | logChannel.send({
788 | embeds: [
789 | new EmbedBuilder()
790 | .setColor(client.color)
791 | .setAuthor({
792 | name: client.user.username,
793 | iconURL: client.user.displayAvatarURL(),
794 | })
795 | .addFields(
796 | {
797 | name: "Category",
798 | value: `> Anti Webhook Create`,
799 | },
800 | {
801 | name: "Log Type",
802 | value: "> User Banned",
803 | },
804 | {
805 | name: "User",
806 | value: `> ${executor} ${executor.id}`,
807 | },
808 | {
809 | name: "Reason",
810 | value: "> Creating Webhooks",
811 | }
812 | )
813 | .setFooter({ text: `© Nityam Antinuke Logs` })
814 | .setTimestamp(),
815 | ],
816 | });
817 | }
818 | }
819 | );
820 | });
821 |
822 | client.on("webhookUpdate", async (webhook) => {
823 | if(!webhook.guild.members.me.permissions.has(PermissionFlagsBits.ViewAuditLog)) return;
824 | const auditLog = await webhook.guild.fetchAuditLogs({
825 | limit: 1,
826 | type: AuditLogEvent.WebhookDelete,
827 | });
828 | const logs = auditLog.entries.first();
829 | if(!logs) return;
830 | const { executor } = logs;
831 |
832 | await GuildSettings.findOne(
833 | { guildId: webhook.guild.id },
834 | async (err, data) => {
835 | if(!data) return;
836 | const antinuke = data.enabled.webhooks;
837 | const trusted = data.whitelist.webhooks.includes(executor.id);
838 | const owner = data.ownerLevel.includes(executor.id);
839 |
840 | if (antinuke === false) return;
841 | if (trusted === true) return;
842 | if (owner === true) return;
843 | if (executor.id === client.user.id) return;
844 | if (executor.id === webhook.guild.ownerId) return;
845 |
846 | const member = webhook.guild.members.fetch(executor.id);
847 | member.ban({ reason: "© Nityam Anti Webhook Delete" });
848 |
849 | const logChannel = webhook.guild.channels.cache.get(data.logChannel);
850 | if (logChannel) {
851 | logChannel.send({
852 | embeds: [
853 | new EmbedBuilder()
854 | .setColor(client.color)
855 | .setAuthor({
856 | name: client.user.username,
857 | iconURL: client.user.displayAvatarURL(),
858 | })
859 | .addFields(
860 | {
861 | name: "Category",
862 | value: `> Anti Webhook Delete`,
863 | },
864 | {
865 | name: "Log Type",
866 | value: "> User Banned",
867 | },
868 | {
869 | name: "User",
870 | value: `> ${executor} ${executor.id}`,
871 | },
872 | {
873 | name: "Reason",
874 | value: "> © Nityam Anti Webhook Delete",
875 | }
876 | )
877 | .setFooter({ text: `© Nityam Antinuke Logs` })
878 | .setTimestamp(),
879 | ],
880 | });
881 | }
882 | }
883 | );
884 | });
885 |
886 | //=================================== Anti Guild Update ===================================//
887 | client.on('guildUpdate', async (o, n) => {
888 |
889 | const auditLog = await o.fetchAuditLogs({
890 | limit: 1,
891 | type: AuditLogEvent.GuildUpdate,
892 | });
893 |
894 | const logs = auditLog.entries.first();
895 |
896 | if (!logs) return;
897 | const { executor } = logs;
898 |
899 | await GuildSettings.findOne(
900 | { guildId: n.id },
901 | async (err, data) => {
902 | if (!data) return;
903 | const antinuke = data.guildId;
904 | const trusted = data.whitelist.guildUpdate.includes(executor.id);
905 | const owner = data.ownerLevel.includes(executor.id);
906 |
907 | if (antinuke === false) return;
908 | if (trusted === true) return;
909 | if (owner === true) return;
910 | if (executor.id === client.user.id) return;
911 |
912 | const oldIcon = o.iconURL();
913 |
914 | const oldName = o.name;
915 |
916 | const newIcon = n.iconURL();
917 | const newName = n.name;
918 |
919 | if (oldName !== newName) {
920 | await n.setName(oldName);
921 | }
922 |
923 | if (oldIcon !== newIcon) {
924 | await o.setIcon(oldIcon);
925 | }
926 |
927 | const member = await n.guild.members.fetch(executor.id);
928 | member.ban({ reason: "© Nityam Anti Guild Update" });
929 | const logChannel = webhook.guild.channels.cache.get(data.logChannel);
930 | if (logChannel) {
931 | logChannel.send({
932 | embeds: [
933 | new EmbedBuilder()
934 | .setColor(client.color)
935 | .setAuthor({
936 | name: client.user.username,
937 | iconURL: client.user.displayAvatarURL(),
938 | })
939 | .addFields(
940 | {
941 | name: "Category",
942 | value: `> Anti Guild Update`,
943 | },
944 | {
945 | name: "Log Type",
946 | value: "> User Banned",
947 | },
948 | {
949 | name: "User",
950 | value: `> ${executor} ${executor.id}`,
951 | },
952 | {
953 | name: "Reason",
954 | value: "> © Nityam Anti Guild Update",
955 | }
956 | )
957 | .setFooter({ text: `© Nityam Antinuke Logs` })
958 | .setTimestamp(),
959 | ],
960 | });
961 | }
962 |
963 |
964 | })
965 | });
966 | };
967 |
--------------------------------------------------------------------------------