style(src/prettier): updating with the prettier

This commit is contained in:
Raphael 2025-08-18 11:46:10 +02:00
parent b36925546c
commit bb46ad3996
17 changed files with 1909 additions and 1717 deletions

View file

@ -1,236 +1,252 @@
import { EmbedBuilder, userMention, MessageFlags, SlashCommandBuilder } from 'discord.js';
import { prisma } from '../../lib/prisma.ts';
import emoji from '../../../assets/emoji.json' assert { type: "json" };
import {
EmbedBuilder,
userMention,
MessageFlags,
SlashCommandBuilder,
} from "discord.js";
import { prisma } from "../../lib/prisma.ts";
import emoji from "../../../assets/emoji.json" assert { type: "json" };
export default {
data: new SlashCommandBuilder()
.setName('buyer')
.setDescription('Interact with the buyers')
.addSubcommand(subcommand => subcommand
.setName('add')
.setDescription('Add a user on the buyer list')
.addUserOption(option =>
option.setName('target')
.setDescription('The user who will be added to the list')
.setRequired(true)
)
)
.addSubcommand(subcommand => subcommand
.setName('delete')
.setDescription('Delete a user on the buyer list')
.addUserOption(option =>
option.setName('target')
.setDescription('The user who will be deleted to the list')
.setRequired(true)
)
)
.addSubcommand(subcommand => subcommand
.setName('list')
.setDescription('The list of the buyer')
),
async execute(interaction: CommandInteraction) {
const subcommand = interaction.options.getSubcommand();
let userData: User;
try {
userData = await prisma.user.findUnique({
where: {
id: interaction.user.id
}
});
} catch (err) {
console.error(`\t⚠ | Cannot get the database connection!\n\t\t(${err}).`);
await interaction.reply({
content: `${emoji.answer.error} | Cannot connect to the database`,
flags: MessageFlags.Ephemeral
});
return;
}
let guildData: Guild;
try {
guildData = await prisma.guild.findUnique({
where: {
id: interaction.guild.id
}
});
} catch (err) {
console.error(`\t⚠ | Cannot get the database connection!\n\t\t(${err}).`);
await interaction.reply({
content: `${emoji.answer.error} | Cannot connect to the database`,
flags: MessageFlags.Ephemeral
});
return;
}
const target: GuildMember = interaction.options.getUser('target')
switch (subcommand) {
case 'add':
if (!userData.isDev) {
await interaction.reply({
content: `${emoji.answer.no} | This command is only for the developper of the bot`,
flags: MessageFlags.Ephemeral
});
return;
}
try {
await prisma.bot.update({
where: {
id: 1
},
data: {
buyers: {
connect: {
id: target.id
}
},
owners: {
connect: {
id: target.id
}
}
}
});
await prisma.user.upsert({
where: {
id: target.id
},
update: {
isBuyer: true,
isOwner: true
},
create: {
id: target.id,
isBuyer: true,
isOwner: true
}
});
} catch (err) {
console.error(`⚠️ | Error when adding ${target.username} to the buyer list`);
await interaction.reply({
content: `${emoji.answer.error} | Error when adding ${target.username} to the owner list`,
flags: MessageFlags.Ephemeral
});
return;
}
await interaction.reply({
content: `${emoji.answer.yes} | ${target.username} has been added to the buyer list`,
flags: MessageFlags.Ephemeral
});
return;
case 'delete':
if (!userData.isDev) {
await interaction.reply({
content: `${emoji.answer.no} | This command is only for buyer`,
flags: MessageFlags.Ephemeral
});
return;
} else if (interaction.user.id === target.id) {
await interaction.reply({
content: `${emoji.answer.no} | You cannot removing yourself from the buyer list`,
flags: MessageFlags.Ephemeral
});
return;
}
try {
await prisma.bot.update({
where: {
id: 1
},
data: {
buyers: {
disconnect: {
id: target.id
}
},
owners: {
disconnect: {
id: target.id
}
}
}
});
await prisma.user.upsert({
where: {
id: target.id
},
update: {
isBuyer: false,
isOwner: false
},
create: {
id: target.id,
isBuyer: false,
isOwner: false
}
});
} catch (err) {
console.error(`⚠️ | Error when removing ${target.username} to the username`);
return;
}
await interaction.reply({
content: `${emoji.answer.yes} | ${target.username} has been removing to the buyer list`,
flags: MessageFlags.Ephemeral
});
return;
case 'list':
if (!userData.isBuyer) {
await interaction.reply({
content: `${emoji.answer.no} | This command is only for buyer`,
flags: MessageFlags.Ephemeral
});
return;
}
try {
const bot = await prisma.bot.findUnique({
where: {
id: 1
},
include: {
buyers: true
}
});
data: new SlashCommandBuilder()
.setName("buyer")
.setDescription("Interact with the buyers")
.addSubcommand((subcommand) =>
subcommand
.setName("add")
.setDescription("Add a user on the buyer list")
.addUserOption((option) =>
option
.setName("target")
.setDescription("The user who will be added to the list")
.setRequired(true),
),
)
.addSubcommand((subcommand) =>
subcommand
.setName("delete")
.setDescription("Delete a user on the buyer list")
.addUserOption((option) =>
option
.setName("target")
.setDescription("The user who will be deleted to the list")
.setRequired(true),
),
)
.addSubcommand((subcommand) =>
subcommand.setName("list").setDescription("The list of the buyer"),
),
async execute(interaction: CommandInteraction) {
const subcommand = interaction.options.getSubcommand();
let userData: User;
try {
userData = await prisma.user.findUnique({
where: {
id: interaction.user.id,
},
});
} catch (err) {
console.error(
`\t⚠ | Cannot get the database connection!\n\t\t(${err}).`,
);
await interaction.reply({
content: `${emoji.answer.error} | Cannot connect to the database`,
flags: MessageFlags.Ephemeral,
});
return;
}
let guildData: Guild;
try {
guildData = await prisma.guild.findUnique({
where: {
id: interaction.guild.id,
},
});
} catch (err) {
console.error(
`\t⚠ | Cannot get the database connection!\n\t\t(${err}).`,
);
await interaction.reply({
content: `${emoji.answer.error} | Cannot connect to the database`,
flags: MessageFlags.Ephemeral,
});
return;
}
const target: GuildMember = interaction.options.getUser("target");
switch (subcommand) {
case "add":
if (!userData.isDev) {
await interaction.reply({
content: `${emoji.answer.no} | This command is only for the developper of the bot`,
flags: MessageFlags.Ephemeral,
});
return;
}
try {
await prisma.bot.update({
where: {
id: 1,
},
data: {
buyers: {
connect: {
id: target.id,
},
},
owners: {
connect: {
id: target.id,
},
},
},
});
await prisma.user.upsert({
where: {
id: target.id,
},
update: {
isBuyer: true,
isOwner: true,
},
create: {
id: target.id,
isBuyer: true,
isOwner: true,
},
});
} catch (err) {
console.error(
`⚠️ | Error when adding ${target.username} to the buyer list`,
);
await interaction.reply({
content: `${emoji.answer.error} | Error when adding ${target.username} to the owner list`,
flags: MessageFlags.Ephemeral,
});
return;
}
await interaction.reply({
content: `${emoji.answer.yes} | ${target.username} has been added to the buyer list`,
flags: MessageFlags.Ephemeral,
});
return;
case "delete":
if (!userData.isDev) {
await interaction.reply({
content: `${emoji.answer.no} | This command is only for buyer`,
flags: MessageFlags.Ephemeral,
});
return;
} else if (interaction.user.id === target.id) {
await interaction.reply({
content: `${emoji.answer.no} | You cannot removing yourself from the buyer list`,
flags: MessageFlags.Ephemeral,
});
return;
}
try {
await prisma.bot.update({
where: {
id: 1,
},
data: {
buyers: {
disconnect: {
id: target.id,
},
},
owners: {
disconnect: {
id: target.id,
},
},
},
});
await prisma.user.upsert({
where: {
id: target.id,
},
update: {
isBuyer: false,
isOwner: false,
},
create: {
id: target.id,
isBuyer: false,
isOwner: false,
},
});
} catch (err) {
console.error(
`⚠️ | Error when removing ${target.username} to the username`,
);
return;
}
await interaction.reply({
content: `${emoji.answer.yes} | ${target.username} has been removing to the buyer list`,
flags: MessageFlags.Ephemeral,
});
return;
case "list":
if (!userData.isBuyer) {
await interaction.reply({
content: `${emoji.answer.no} | This command is only for buyer`,
flags: MessageFlags.Ephemeral,
});
return;
}
try {
const bot = await prisma.bot.findUnique({
where: {
id: 1,
},
include: {
buyers: true,
},
});
if (!bot || bot.buyers.length === 0) {
await interaction.reply({
content: `${emoji.answer.error} | There is no buyer registered.`,
flags: MessageFlags.Ephemeral
});
break;
}
if (!bot || bot.buyers.length === 0) {
await interaction.reply({
content: `${emoji.answer.error} | There is no buyer registered.`,
flags: MessageFlags.Ephemeral,
});
break;
}
const buyerList = await Promise.all(
bot.buyers.map(async (buyer) => {
try {
const user = await interaction.client.users.fetch(buyer.id);
return `- ${user.username} (\`${user.id}\`)\n`;
} catch (err) {
console.warn(`⚠️ | ${buyer.id} : ${err}`);
return null;
}
})
);
const buyerList = await Promise.all(
bot.buyers.map(async (buyer) => {
try {
const user = await interaction.client.users.fetch(buyer.id);
return `- ${user.username} (\`${user.id}\`)\n`;
} catch (err) {
console.warn(`⚠️ | ${buyer.id} : ${err}`);
return null;
}
}),
);
const toSend: EmbedBuilder = new EmbedBuilder()
.setTitle(`${emoji.badge.buyer} | Buyer list`)
.setColor(guildData.color)
.setFooter({
text: guildData.footer
})
.setDescription(buyerList.filter(Boolean).join(''))
await interaction.reply({
embeds: [
toSend
],
flags: MessageFlags.Ephemeral
});
} catch (err) {
console.error(`⚠️ | error when fetching infromation from the database: ${err}`);
await interaction.reply({
content: `${emoji.answer.error} | Cannot fetch the infromation of the database.`,
flags: MessageFlags.Ephemeral
});
return;
}
break;
return;
}
}
}
const toSend: EmbedBuilder = new EmbedBuilder()
.setTitle(`${emoji.badge.buyer} | Buyer list`)
.setColor(guildData.color)
.setFooter({
text: guildData.footer,
})
.setDescription(buyerList.filter(Boolean).join(""));
await interaction.reply({
embeds: [toSend],
flags: MessageFlags.Ephemeral,
});
} catch (err) {
console.error(
`⚠️ | error when fetching infromation from the database: ${err}`,
);
await interaction.reply({
content: `${emoji.answer.error} | Cannot fetch the infromation of the database.`,
flags: MessageFlags.Ephemeral,
});
return;
}
break;
return;
}
},
};

View file

@ -1,225 +1,241 @@
import { EmbedBuilder, userMention, MessageFlags, SlashCommandBuilder } from 'discord.js';
import { prisma } from '../../lib/prisma.ts';
import emoji from '../../../assets/emoji.json' assert { type: "json" };
import {
EmbedBuilder,
userMention,
MessageFlags,
SlashCommandBuilder,
} from "discord.js";
import { prisma } from "../../lib/prisma.ts";
import emoji from "../../../assets/emoji.json" assert { type: "json" };
export default {
data: new SlashCommandBuilder()
.setName('owner')
.setDescription('Interact with the owners')
.addSubcommand(subcommand => subcommand
.setName('add')
.setDescription('Add a user on the owner list')
.addUserOption(option =>
option.setName('target')
.setDescription('The user who will be added to the list')
.setRequired(true)
)
)
.addSubcommand(subcommand => subcommand
.setName('delete')
.setDescription('Delete a user on the owner list')
.addUserOption(option =>
option.setName('target')
.setDescription('The user who will be deleted to the list')
.setRequired(true)
)
)
.addSubcommand(subcommand => subcommand
.setName('list')
.setDescription('The list of the owner')
),
async execute(interaction: CommandInteraction) {
const subcommand = interaction.options.getSubcommand();
let userData: User;
try {
userData = await prisma.user.findUnique({
where: {
id: interaction.user.id
}
});
} catch (err) {
console.error(`\t⚠ | Cannot get the database connection!\n\t\t(${err}).`);
await interaction.reply({
content: `${emoji.answer.error} | Cannot connect to the database`,
flags: MessageFlags.Ephemeral
});
return;
}
let guildData: Guild;
try {
guildData = await prisma.guild.findUnique({
where: {
id: interaction.guild.id
}
});
} catch (err) {
console.error(`\t⚠ | Cannot get the database connection!\n\t\t(${err}).`);
await interaction.reply({
content: `${emoji.answer.error} | Cannot connect to the database`,
flags: MessageFlags.Ephemeral
});
return;
}
const target: GuildMember = interaction.options.getUser('target')
switch (subcommand) {
case 'add':
if (!userData.isBuyer) {
await interaction.reply({
content: `${emoji.answer.no} | This command is only for buyer`,
flags: MessageFlags.Ephemeral
});
return;
}
try {
await prisma.bot.update({
where: {
id: 1
},
data: {
owners: {
connect: {
id: target.id
}
}
}
});
await prisma.user.upsert({
where: {
id: target.id
},
update: {
isOwner: true
},
create: {
id: target.id,
isOwner: true
}
});
} catch (err) {
console.error(`⚠️ | Error when adding ${target.username} to the username`);
await interaction.reply({
content: `${emoji.answer.error} | Error when adding ${target.username} to the owner list`,
flags: MessageFlags.Ephemeral
});
return;
}
await interaction.reply({
content: `${emoji.answer.yes} | ${target.username} has been added to the owner list`,
flags: MessageFlags.Ephemeral
});
return;
case 'delete':
if (!userData.isBuyer) {
await interaction.reply({
content: `${emoji.answer.no} | This command is only for buyer`,
flags: MessageFlags.Ephemeral
});
return;
} else if (interaction.user.id === target.id) {
await interaction.reply({
content: `${emoji.answer.no} | You cannot removing yourself from the owner list`,
flags: MessageFlags.Ephemeral
});
return;
}
try {
await prisma.bot.update({
where: {
id: 1
},
data: {
owners: {
disconnect: {
id: target.id
}
}
}
});
await prisma.user.upsert({
where: {
id: target.id
},
update: {
isOwner: false
},
create: {
id: target.id,
isOwner: false
}
});
} catch (err) {
console.error(`⚠️ | Error when removing ${target.username} to the username`);
await interaction.reply({
content: `${emoji.answer.error} | Cannot removing the user from the owner list`,
flags: MessageFlags.Ephemeral
});
return;
}
await interaction.reply({
content: `${emoji.answer.yes} | ${target.username} has been removing to the owner list`,
flags: MessageFlags.Ephemeral
});
return;
case 'list':
if (!userData.isOwner) {
await interaction.reply({
content: `${emoji.answer.no} | This command is only for owner`,
flags: MessageFlags.Ephemeral
});
return;
}
try {
const bot = await prisma.bot.findUnique({
where: {
id: 1
},
include: {
owners: true
}
});
data: new SlashCommandBuilder()
.setName("owner")
.setDescription("Interact with the owners")
.addSubcommand((subcommand) =>
subcommand
.setName("add")
.setDescription("Add a user on the owner list")
.addUserOption((option) =>
option
.setName("target")
.setDescription("The user who will be added to the list")
.setRequired(true),
),
)
.addSubcommand((subcommand) =>
subcommand
.setName("delete")
.setDescription("Delete a user on the owner list")
.addUserOption((option) =>
option
.setName("target")
.setDescription("The user who will be deleted to the list")
.setRequired(true),
),
)
.addSubcommand((subcommand) =>
subcommand.setName("list").setDescription("The list of the owner"),
),
async execute(interaction: CommandInteraction) {
const subcommand = interaction.options.getSubcommand();
let userData: User;
try {
userData = await prisma.user.findUnique({
where: {
id: interaction.user.id,
},
});
} catch (err) {
console.error(
`\t⚠ | Cannot get the database connection!\n\t\t(${err}).`,
);
await interaction.reply({
content: `${emoji.answer.error} | Cannot connect to the database`,
flags: MessageFlags.Ephemeral,
});
return;
}
let guildData: Guild;
try {
guildData = await prisma.guild.findUnique({
where: {
id: interaction.guild.id,
},
});
} catch (err) {
console.error(
`\t⚠ | Cannot get the database connection!\n\t\t(${err}).`,
);
await interaction.reply({
content: `${emoji.answer.error} | Cannot connect to the database`,
flags: MessageFlags.Ephemeral,
});
return;
}
const target: GuildMember = interaction.options.getUser("target");
switch (subcommand) {
case "add":
if (!userData.isBuyer) {
await interaction.reply({
content: `${emoji.answer.no} | This command is only for buyer`,
flags: MessageFlags.Ephemeral,
});
return;
}
try {
await prisma.bot.update({
where: {
id: 1,
},
data: {
owners: {
connect: {
id: target.id,
},
},
},
});
await prisma.user.upsert({
where: {
id: target.id,
},
update: {
isOwner: true,
},
create: {
id: target.id,
isOwner: true,
},
});
} catch (err) {
console.error(
`⚠️ | Error when adding ${target.username} to the username`,
);
await interaction.reply({
content: `${emoji.answer.error} | Error when adding ${target.username} to the owner list`,
flags: MessageFlags.Ephemeral,
});
return;
}
await interaction.reply({
content: `${emoji.answer.yes} | ${target.username} has been added to the owner list`,
flags: MessageFlags.Ephemeral,
});
return;
case "delete":
if (!userData.isBuyer) {
await interaction.reply({
content: `${emoji.answer.no} | This command is only for buyer`,
flags: MessageFlags.Ephemeral,
});
return;
} else if (interaction.user.id === target.id) {
await interaction.reply({
content: `${emoji.answer.no} | You cannot removing yourself from the owner list`,
flags: MessageFlags.Ephemeral,
});
return;
}
try {
await prisma.bot.update({
where: {
id: 1,
},
data: {
owners: {
disconnect: {
id: target.id,
},
},
},
});
await prisma.user.upsert({
where: {
id: target.id,
},
update: {
isOwner: false,
},
create: {
id: target.id,
isOwner: false,
},
});
} catch (err) {
console.error(
`⚠️ | Error when removing ${target.username} to the username`,
);
await interaction.reply({
content: `${emoji.answer.error} | Cannot removing the user from the owner list`,
flags: MessageFlags.Ephemeral,
});
return;
}
await interaction.reply({
content: `${emoji.answer.yes} | ${target.username} has been removing to the owner list`,
flags: MessageFlags.Ephemeral,
});
return;
case "list":
if (!userData.isOwner) {
await interaction.reply({
content: `${emoji.answer.no} | This command is only for owner`,
flags: MessageFlags.Ephemeral,
});
return;
}
try {
const bot = await prisma.bot.findUnique({
where: {
id: 1,
},
include: {
owners: true,
},
});
if (!bot || bot.owners.length === 0) {
await interaction.reply({
content: `${emoji.answer.error} | There is no owner registered.`,
flags: MessageFlags.Ephemeral
});
break;
}
if (!bot || bot.owners.length === 0) {
await interaction.reply({
content: `${emoji.answer.error} | There is no owner registered.`,
flags: MessageFlags.Ephemeral,
});
break;
}
const ownerList = await Promise.all(
bot.owners.map(async (owner) => {
try {
const user = await interaction.client.users.fetch(owner.id);
return `- ${user.username} (\`${user.id}\`)\n`;
} catch (err) {
console.warn(`⚠️ | ${owner.id} : ${err}`);
return null;
}
})
);
const ownerList = await Promise.all(
bot.owners.map(async (owner) => {
try {
const user = await interaction.client.users.fetch(owner.id);
return `- ${user.username} (\`${user.id}\`)\n`;
} catch (err) {
console.warn(`⚠️ | ${owner.id} : ${err}`);
return null;
}
}),
);
const toSend: EmbedBuilder = new EmbedBuilder()
.setTitle(`${emoji.badge.owner} | Owner list`)
.setColor(guildData.color)
.setFooter({
text: guildData.footer
})
.setDescription(ownerList.filter(Boolean).join(''))
await interaction.reply({
embeds: [
toSend
],
flags: MessageFlags.Ephemeral
});
} catch (err) {
console.error(`⚠️ | error when fetching infromation from the database: ${err}`);
await interaction.reply({
content: `${emoji.answer.error} | Cannot fetch the infromation of the database.`,
flags: MessageFlags.Ephemeral
});
}
break;
return;
}
}
}
const toSend: EmbedBuilder = new EmbedBuilder()
.setTitle(`${emoji.badge.owner} | Owner list`)
.setColor(guildData.color)
.setFooter({
text: guildData.footer,
})
.setDescription(ownerList.filter(Boolean).join(""));
await interaction.reply({
embeds: [toSend],
flags: MessageFlags.Ephemeral,
});
} catch (err) {
console.error(
`⚠️ | error when fetching infromation from the database: ${err}`,
);
await interaction.reply({
content: `${emoji.answer.error} | Cannot fetch the infromation of the database.`,
flags: MessageFlags.Ephemeral,
});
}
break;
return;
}
},
};

View file

@ -1,233 +1,249 @@
import { EmbedBuilder, userMention, MessageFlags, SlashCommandBuilder } from 'discord.js';
import { prisma } from '../../lib/prisma.ts';
import emoji from '../../../assets/emoji.json' assert { type: "json" };
import {
EmbedBuilder,
userMention,
MessageFlags,
SlashCommandBuilder,
} from "discord.js";
import { prisma } from "../../lib/prisma.ts";
import emoji from "../../../assets/emoji.json" assert { type: "json" };
export default {
data: new SlashCommandBuilder()
.setName('whitelist')
.setDescription('Interact with the whitelist')
.addSubcommand(subcommand => subcommand
.setName('add')
.setDescription('Add a user on the whitelist')
.addUserOption(option =>
option.setName('target')
.setDescription('The user who will be added to the whitelist')
.setRequired(true)
)
)
.addSubcommand(subcommand => subcommand
.setName('delete')
.setDescription('Delete a user on the whitelist')
.addUserOption(option =>
option.setName('target')
.setDescription('The user who will be deleted to the whitelist')
.setRequired(true)
)
)
.addSubcommand(subcommand => subcommand
.setName('list')
.setDescription('Show the whitelist')
),
async execute(interaction: CommandInteraction) {
const subcommand = interaction.options.getSubcommand();
let userData: User;
try {
userData = await prisma.user.findUnique({
where: {
id: interaction.user.id
}
});
} catch (err) {
console.error(`\t⚠ | Whitelist => Cannot get the database connection!\n\t\t(${err}).`);
await interaction.reply({
content: `${emoji.answer.error} | Cannot connect to the database`,
flags: MessageFlags.Ephemeral
});
return;
}
let guildData: Guild;
try {
guildData = await prisma.guild.findUnique({
where: {
id: interaction.guild.id
}
});
} catch (err) {
console.error(`\t⚠ | Cannot get the database connection!\n\t\t(${err}).`);
await interaction.reply({
content: `${emoji.answer.error} | Cannot connect to the database`,
flags: MessageFlags.Ephemeral
});
return;
}
const target: GuildMember = interaction.options.getUser('target')
switch (subcommand) {
case 'add':
if (!userData.isOwner) {
await interaction.reply({
content: `${emoji.answer.no} | This command is only for owner`,
flags: MessageFlags.Ephemeral
});
return;
}
try {
await prisma.guildUser.upsert({
where: {
userId_guildId: {
userId: target.id,
guildId: interaction.guild.id
}
},
update: {
isWlUser: true
},
create: {
userId: target.id,
guildId: interaction.guild.id,
isWlUser: true
}
});
await prisma.guild.update({
where: {
id: interaction.guild.id
},
data: {
WlUsers: {
connect: {
id: target.id
}
}
}
});
} catch (err) {
console.error(`⚠️ | Error when adding ${target.username} to the whitelist\n\t${err}`);
await interaction.reply({
content: `${emoji.answer.error} | Error when adding ${target.username} to the whitelist`,
flags: MessageFlags.Ephemeral
});
return;
}
await interaction.reply({
content: `${emoji.answer.yes} | ${target.username} has been added to the whitelist`,
flags: MessageFlags.Ephemeral
});
return;
case 'delete':
if (!userData.isOwner) {
await interaction.reply({
content: `${emoji.answer.no} | This command is only for owner`,
flags: MessageFlags.Ephemeral
});
return;
} else if (interaction.user.id === target.id) {
await interaction.reply({
content: `${emoji.answer.no} | You cannot removing yourself from the whitelist`,
flags: MessageFlags.Ephemeral
});
return;
}
try {
await prisma.guildUser.upsert({
where: {
userId_guildId: {
userId: target.id,
guildId: interaction.guild.id
}
},
update: {
isWlUser: false
},
create: {
userId: target.id,
guildId: interaction.guild.id,
isWlUser: false
}
});
await prisma.guild.update({
where: {
id: interaction.guild.id
},
data: {
WlUsers: {
disconnect: {
id: target.id
}
}
}
});
} catch (err) {
console.error(`⚠️ | Error when removing ${target.username} to the username\n\t${err}`);
await interaction.reply({
content: `${emoji.answer.error} | Cannot remove ${target.username} from the whitelist`,
flags: MessageFlags.Ephemeral
});
return;
}
await interaction.reply({
content: `${emoji.answer.yes} | ${target.username} has been removing to the whitelist`,
flags: MessageFlags.Ephemeral
});
return;
case 'list':
if (!userData.isOwner) {
await interaction.reply({
content: `${emoji.answer.no} | This command is only for owner`,
flags: MessageFlags.Ephemeral
});
return;
}
try {
const guild = await prisma.guild.findUnique({
where: {
id: interaction.guild.id
},
include: {
WlUsers: true
}
});
data: new SlashCommandBuilder()
.setName("whitelist")
.setDescription("Interact with the whitelist")
.addSubcommand((subcommand) =>
subcommand
.setName("add")
.setDescription("Add a user on the whitelist")
.addUserOption((option) =>
option
.setName("target")
.setDescription("The user who will be added to the whitelist")
.setRequired(true),
),
)
.addSubcommand((subcommand) =>
subcommand
.setName("delete")
.setDescription("Delete a user on the whitelist")
.addUserOption((option) =>
option
.setName("target")
.setDescription("The user who will be deleted to the whitelist")
.setRequired(true),
),
)
.addSubcommand((subcommand) =>
subcommand.setName("list").setDescription("Show the whitelist"),
),
async execute(interaction: CommandInteraction) {
const subcommand = interaction.options.getSubcommand();
let userData: User;
try {
userData = await prisma.user.findUnique({
where: {
id: interaction.user.id,
},
});
} catch (err) {
console.error(
`\t⚠ | Whitelist => Cannot get the database connection!\n\t\t(${err}).`,
);
await interaction.reply({
content: `${emoji.answer.error} | Cannot connect to the database`,
flags: MessageFlags.Ephemeral,
});
return;
}
let guildData: Guild;
try {
guildData = await prisma.guild.findUnique({
where: {
id: interaction.guild.id,
},
});
} catch (err) {
console.error(
`\t⚠ | Cannot get the database connection!\n\t\t(${err}).`,
);
await interaction.reply({
content: `${emoji.answer.error} | Cannot connect to the database`,
flags: MessageFlags.Ephemeral,
});
return;
}
const target: GuildMember = interaction.options.getUser("target");
switch (subcommand) {
case "add":
if (!userData.isOwner) {
await interaction.reply({
content: `${emoji.answer.no} | This command is only for owner`,
flags: MessageFlags.Ephemeral,
});
return;
}
try {
await prisma.guildUser.upsert({
where: {
userId_guildId: {
userId: target.id,
guildId: interaction.guild.id,
},
},
update: {
isWlUser: true,
},
create: {
userId: target.id,
guildId: interaction.guild.id,
isWlUser: true,
},
});
await prisma.guild.update({
where: {
id: interaction.guild.id,
},
data: {
WlUsers: {
connect: {
id: target.id,
},
},
},
});
} catch (err) {
console.error(
`⚠️ | Error when adding ${target.username} to the whitelist\n\t${err}`,
);
await interaction.reply({
content: `${emoji.answer.error} | Error when adding ${target.username} to the whitelist`,
flags: MessageFlags.Ephemeral,
});
return;
}
await interaction.reply({
content: `${emoji.answer.yes} | ${target.username} has been added to the whitelist`,
flags: MessageFlags.Ephemeral,
});
return;
case "delete":
if (!userData.isOwner) {
await interaction.reply({
content: `${emoji.answer.no} | This command is only for owner`,
flags: MessageFlags.Ephemeral,
});
return;
} else if (interaction.user.id === target.id) {
await interaction.reply({
content: `${emoji.answer.no} | You cannot removing yourself from the whitelist`,
flags: MessageFlags.Ephemeral,
});
return;
}
try {
await prisma.guildUser.upsert({
where: {
userId_guildId: {
userId: target.id,
guildId: interaction.guild.id,
},
},
update: {
isWlUser: false,
},
create: {
userId: target.id,
guildId: interaction.guild.id,
isWlUser: false,
},
});
await prisma.guild.update({
where: {
id: interaction.guild.id,
},
data: {
WlUsers: {
disconnect: {
id: target.id,
},
},
},
});
} catch (err) {
console.error(
`⚠️ | Error when removing ${target.username} to the username\n\t${err}`,
);
await interaction.reply({
content: `${emoji.answer.error} | Cannot remove ${target.username} from the whitelist`,
flags: MessageFlags.Ephemeral,
});
return;
}
await interaction.reply({
content: `${emoji.answer.yes} | ${target.username} has been removing to the whitelist`,
flags: MessageFlags.Ephemeral,
});
return;
case "list":
if (!userData.isOwner) {
await interaction.reply({
content: `${emoji.answer.no} | This command is only for owner`,
flags: MessageFlags.Ephemeral,
});
return;
}
try {
const guild = await prisma.guild.findUnique({
where: {
id: interaction.guild.id,
},
include: {
WlUsers: true,
},
});
if (!guild || guild.WlUsers.length === 0) {
await interaction.reply({
content: `${emoji.answer.error} | There is no whitelisted user.`,
flags: MessageFlags.Ephemeral
});
break;
}
if (!guild || guild.WlUsers.length === 0) {
await interaction.reply({
content: `${emoji.answer.error} | There is no whitelisted user.`,
flags: MessageFlags.Ephemeral,
});
break;
}
const WlUsers = await Promise.all(
guild.WlUsers.map(async (whitelist) => {
try {
const user = await interaction.client.users.fetch(whitelist.id);
return `- ${user.username} (\`${user.id}\`)\n`;
} catch (err) {
console.warn(`⚠️ | ${whitelist.id} : ${err}`);
return null;
}
})
);
const WlUsers = await Promise.all(
guild.WlUsers.map(async (whitelist) => {
try {
const user = await interaction.client.users.fetch(whitelist.id);
return `- ${user.username} (\`${user.id}\`)\n`;
} catch (err) {
console.warn(`⚠️ | ${whitelist.id} : ${err}`);
return null;
}
}),
);
const toSend: EmbedBuilder = new EmbedBuilder()
.setTitle(`🗞️ | Whitelist`)
.setColor(guildData.color)
.setFooter({
text: guildData.footer
})
.setDescription(WlUsers.filter(Boolean).join(''))
await interaction.reply({
embeds: [
toSend
],
flags: MessageFlags.Ephemeral
});
} catch (err) {
console.error(`⚠️ | Whitelist => error when fetching infromation from the database: ${err}`);
await interaction.reply({
content: `${emoji.answer.error} | Cannot fetch the infromation of the database.`,
flags: MessageFlags.Ephemeral
});
}
break;
return;
}
}
}
const toSend: EmbedBuilder = new EmbedBuilder()
.setTitle(`🗞️ | Whitelist`)
.setColor(guildData.color)
.setFooter({
text: guildData.footer,
})
.setDescription(WlUsers.filter(Boolean).join(""));
await interaction.reply({
embeds: [toSend],
flags: MessageFlags.Ephemeral,
});
} catch (err) {
console.error(
`⚠️ | Whitelist => error when fetching infromation from the database: ${err}`,
);
await interaction.reply({
content: `${emoji.answer.error} | Cannot fetch the infromation of the database.`,
flags: MessageFlags.Ephemeral,
});
}
break;
return;
}
},
};