Skip to content
The Chat Archive
o1-mini-2024-09-12· OpenAI WildChat-4.8M (AI2)

melhore esse código melhore esse código const Event = require('../../structures/Event')…

  1. User

    melhore esse código

    melhore esse código

    const Event = require('../../structures/Event') const { ButtonBuilder, ActionRowBuilder, StringSelectMenuBuilder, EmbedBuilder, InteractionType, PermissionsBitField, ChannelType, StringSelectMenuOptionBuilder, ButtonStyle } = require('discord.js')

    const ticketConfig = require('../../utils/ticketConfig') const { defaultPermissions, embedLogsTicket } = require('../../utils/exports')

    module.exports = class extends Event { constructor(client) { super(client, { name: 'interactionCreate' }) }

    run = async (interaction) => {
        if (!interaction.guild) return
        if (!interaction) return
    
        if (interaction.type === InteractionType.ApplicationCommand) {
            const cmd = this.client.slashCommands.find(c => c.name == interaction.commandName)
    
            if (cmd) {
                cmd.run(interaction)
            }
        } else if (interaction.type === InteractionType.MessageComponent) {
            if (interaction.customId.startsWith('openTicket')) {
                const channel = await interaction.guild.channels.create({
                    name: `ticket-${interaction.user.username}`,
                    type: ChannelType.GuildText,
                    parent: ticketConfig.openTicketCategory,
                    topic: `ticket-waiting-${interaction.user.id}`,
                    permissionOverwrites: [
                        {
                            id: interaction.guild.id,
                            deny: [PermissionsBitField.Flags.ViewChannel]
                        },
                        {
                            id: interaction.user.id,
                            allow: [
                                defaultPermissions
                            ]
                        },
                    ]
                })
    
                interaction.reply({ content: `Seu ticket foi aberto com sucesso no canal ${channel.toString()}!`, ephemeral: true })
    
                const buttons = ticketConfig.ticketCategories.map(c => c.button).map(x => new StringSelectMenuOptionBuilder(x))
                const row = new ActionRowBuilder()
                    .addComponents([
                        new StringSelectMenuBuilder()
                            .setCustomId(`ticketSelectMenu`)
                            .setPlaceholder('Selecione uma categoria')
                            .addOptions(buttons)
                    ])
    
                const msg = await channel.send({ content: interaction.user.toString(), embeds: [ticketConfig.openTicketEmbed], components: [row] })
                msg.pin()
    
                setTimeout(async () => {
                    const topic = channel.topic.split('-')[1]
                    if (topic == 'waiting') {
                        const closingButton = new ActionRowBuilder()
                            .addComponents(
                                new ButtonBuilder()
                                    .setCustomId('nil')
                                    .setLabel('Deletando ticket...')
                                    .setEmoji('🗑️')
                                    .setStyle(ButtonStyle.Secondary)
                                    .setDisabled(true),
                            );
    
                        await msg.edit({ components: [closingButton] })
                        await channel.send({ content: 'Você demorou muito para selecionar. Deletando ticket...' })
    
                        setTimeout(() => {
                            channel.delete().catch()
                        }, 2000)
                    }
                }, 20000)
            } else if (interaction.customId === 'closeTicket') {
                let topic = interaction.channel.topic.split('-')[2]
    
                if (!interaction.guild.members.cache.has(topic)) {
                    return interaction.reply({ content: `${interaction.user}, o dono do ticket saiu do servidor. Aguarde um administrador deletar o ticket manualmente.` })
                }
    
                if (!interaction.channel.permissionsFor(topic).has([PermissionsBitField.Flags.ViewChannel])) { return interaction.reply({ content: 'Esse ticket já está fechado!', ephemeral: true }) }
    
                await interaction.channel.permissionOverwrites.edit(
                    interaction.channel.topic.split('-')[2],
                    { ViewChannel: false }
                ).catch(e => {
                    console.log(e)
                    return interaction.reply(`${interaction.user.username}, alguma coisa aconteceu de errado ao fechar esse ticket`)
                })
    
                const deleteButton = new ButtonBuilder()
                    .setLabel('Deletar ticket')
                    .setEmoji('🗑')
                    .setCustomId('deleteTicket')
                    .setStyle(ButtonStyle.Danger)
    
                const row = new ActionRowBuilder().addComponents(deleteButton)
    
                const embed = new EmbedBuilder()
                    .setDescription(`O ticket foi fechado por ${interaction.user}`)
                    .setColor('#FF0000')
    
                interaction.message.edit({
                    components: [
                        new ActionRowBuilder().addComponents(
                            new ButtonBuilder(interaction.message.components[0].components[0].data)
                                .setDisabled(true)
                        )]
                })
                interaction.reply({ embeds: [embed], components: [row] }).catch((e) => { console.log(e) })
    
                interaction.guild.channels.cache.get(ticketConfig.logsChannel).send({ embeds: [embedLogsTicket(interaction, interaction.channel.name, 'Fechado', '#ffff00')] }).catch()
            } else if (interaction.customId === 'deleteTicket') {
                if (!interaction.member.permissions.has(PermissionsBitField.Flags.Administrator) && !(interaction.member.member.roles.cache.some(r => ticketConfig.staffRoles.includes(r.id)))) return interaction.reply({ content: 'Você precisa de permissão para executar esse comando.', ephemeral: true })
    
                interaction.message.edit({
                    components: [
                        new ActionRowBuilder().addComponents(
                            new ButtonBuilder(interaction.message.components[0].components[0].data)
                                .setDisabled(true),
                        )
                    ]
                })
    
                await interaction.reply({ content: 'O ticket será deletado em 5 segundos.' })
                interaction.guild.channels.cache.get(ticketConfig.logsChannel).send({ embeds: [embedLogsTicket(interaction, interaction.channel.name, 'Deletado', '#ff0000')] }).catch()
    
                setTimeout(() => {
                    if (interaction && interaction.channel) {
                        interaction.channel.delete().catch()
                    }
                }, 5000)
            } else if (interaction.customId.startsWith('ticketSelectMenu')) {
                const ticketObject = ticketConfig.ticketCategories.find(n => n.name.toLowerCase() === interaction.values[0].toLowerCase());
                if (!ticketObject) return
    
                const category = ticketObject.category
    
                let count = 0
    
                const allChannels = interaction.guild.channels.cache
                    .filter(c => c.type === ChannelType.GuildText && c.permissionsFor(interaction.user.id).has([PermissionsBitField.Flags.ViewChannel]) && (c.parentId === category))
    
                allChannels.forEach(i => {
                    if (count == 1 || !i.topic) return
    
                    const topicSplit = i.topic.split('-')[1]
    
                    if ((i.topic).includes(`${interaction.user.id}`) && (topicSplit == ticketObject.name)) {
                        count++;
                        return interaction.reply({ content: 'Você já tem um ticket dessa categoria aberto!', ephemeral: true })
                    }
    
                })
    
                if (count) { return }
    
    
                interaction.channel.edit({
                    name: `${ticketObject.name}-${interaction.user.username}`,
                    topic: `ticket-${ticketObject.name}-${interaction.user.id}`,
                    parent: category,
                    permissionOverwrites: [
                        {
                            id: interaction.guild.id,
                            deny: [PermissionsBitField.Flags.ViewChannel]
                        },
                        {
                            id: interaction.user.id,
                            allow: [defaultPermissions]
                        },
                        ...ticketObject.staffRoles
    
                    ]
                })
    
                const embed = new EmbedBuilder()
                    .setColor('#2B2D31')
                    .setDescription(`👋 Olá ${interaction.user}, tudo bem?\n\nEm breve um membro da nossa **equipe** responsável pela categoria selecionada irá te responder.\n\nDescreva com **detalhes** o motivo do seu ticket para **agilizar** o atendimento, se\nnecessário o envio de algum tipo de arquivo, envie-o antecipadamente para que\no atendimento seja realizado mais rápido.\n\n*Por favor, não marque nenhum membro da equipe nessa sala.*`)
    
                const row = new ActionRowBuilder()
                    .addComponents(
                        new ButtonBuilder()
                            .setCustomId('closeTicket')
                            .setLabel('Fechar ticket')
                            .setEmoji('🔒')
                            .setStyle(ButtonStyle.Secondary),
                    );
    
    
                interaction.message.edit({
                    embeds: [embed],
                    components: [row]
                })
    
                interaction.guild.channels.cache.get(ticketConfig.logsChannel).send({ embeds: [embedLogsTicket(interaction, `${ticketObject.name}-${interaction.user.username}`, 'Aberto', '#00ff00')] }).catch()
    
                interaction.deferUpdate()
            }
        }
    }
    

    }

  2. Assistant

    Claro! Vamos refatorar o código para torná-lo mais organizado, legível e eficiente. As melhorias incluirão:

    1. Separação de Responsabilidades: Dividir o código em funções menores para facilitar a manutenção.
    2. Tratamento de Erros: Implementar um tratamento de erros mais robusto.
    3. Desestruturação: Utilizar desestruturação para melhorar a legibilidade.
    4. Uso de Constantes: Definir constantes para valores reutilizáveis.
    5. Redução de Redundâncias: Evitar repetições de código utilizando funções auxiliares.

    Aqui está a versão melhorada do seu código:

    const Event = require('../../structures/Event')
    const {
        ButtonBuilder,
        ActionRowBuilder,
        StringSelectMenuBuilder,
        EmbedBuilder,
        InteractionType,
        PermissionsBitField,
        ChannelType,
        StringSelectMenuOptionBuilder,
        ButtonStyle
    } = require('discord.js')
    
    const ticketConfig = require('../../utils/ticketConfig')
    const { defaultPermissions, embedLogsTicket } = require('../../utils/exports')
    
    module.exports = class extends Event {
        constructor(client) {
            super(client, {
                name: 'interactionCreate'
            })
        }
    
        /**
         * Método executado quando uma interação é criada
         * @param {Interaction} interaction
         */
        async run(interaction) {
            if (!interaction.guild || !interaction) return
    
            try {
                switch (interaction.type) {
                    case InteractionType.ApplicationCommand:
                        await this.handleSlashCommand(interaction)
                        break
                    case InteractionType.MessageComponent:
                        await this.handleMessageComponent(interaction)
                        break
                    default:
                        break
                }
            } catch (error) {
                console.error('Erro ao processar a interação:', error)
                if (interaction.replied || interaction.deferred) {
                    await interaction.followUp({ content: 'Ocorreu um erro ao processar sua solicitação.', ephemeral: true })
                } else {
                    await interaction.reply({ content: 'Ocorreu um erro ao processar sua solicitação.', ephemeral: true })
                }
            }
        }
    
        /**
         * Trata comandos de barra (slash commands)
         * @param {Interaction} interaction
         */
        async handleSlashCommand(interaction) {
            const command = this.client.slashCommands.get(interaction.commandName)
            if (!command) return
    
            await command.run(interaction)
        }
    
        /**
         * Trata componentes de mensagem (botões, menus de seleção, etc.)
         * @param {Interaction} interaction
         */
        async handleMessageComponent(interaction) {
            const { customId } = interaction
    
            if (customId.startsWith('openTicket')) {
                await this.openTicket(interaction)
            } else if (customId === 'closeTicket') {
                await this.closeTicket(interaction)
            } else if (customId === 'deleteTicket') {
                await this.deleteTicket(interaction)
            } else if (customId.startsWith('ticketSelectMenu')) {
                await this.selectTicketCategory(interaction)
            }
        }
    
        /**
         * Abre um ticket criando um novo canal
         * @param {Interaction} interaction
         */
        async openTicket(interaction) {
            const { guild, user } = interaction
            const categoryId = ticketConfig.openTicketCategory
    
            const channelName = `ticket-${user.username}`
    
            const channel = await guild.channels.create({
                name: channelName,
                type: ChannelType.GuildText,
                parent: categoryId,
                topic: `ticket-waiting-${user.id}`,
                permissionOverwrites: [
                    {
                        id: guild.id,
                        deny: [PermissionsBitField.Flags.ViewChannel]
                    },
                    {
                        id: user.id,
                        allow: defaultPermissions
                    },
                ]
            })
    
            await interaction.reply({
                content: `Seu ticket foi aberto com sucesso no canal ${channel.toString()}!`,
                ephemeral: true
            })
    
            const selectOptions = ticketConfig.ticketCategories.map(category => ({
                label: category.name,
                value: category.name.toLowerCase(),
                description: category.description || '',
                emoji: category.emoji || undefined
            }))
    
            const selectMenu = new StringSelectMenuBuilder()
                .setCustomId('ticketSelectMenu')
                .setPlaceholder('Selecione uma categoria')
                .addOptions(selectOptions)
    
            const actionRow = new ActionRowBuilder().addComponents(selectMenu)
    
            const embed = new EmbedBuilder(ticketConfig.openTicketEmbed)
    
            const ticketMessage = await channel.send({
                content: user.toString(),
                embeds: [embed],
                components: [actionRow]
            })
    
            await ticketMessage.pin()
    
            // Timeout para esperar seleção da categoria
            setTimeout(async () => {
                if (!channel.topic.includes('waiting')) return
    
                const disabledButton = new ButtonBuilder()
                    .setCustomId('nil')
                    .setLabel('Deletando ticket...')
                    .setEmoji('🗑️')
                    .setStyle(ButtonStyle.Secondary)
                    .setDisabled(true)
    
                const closingRow = new ActionRowBuilder().addComponents(disabledButton)
    
                await ticketMessage.edit({ components: [closingRow] })
                await channel.send({ content: 'Você demorou muito para selecionar. Deletando ticket...' })
    
                setTimeout(() => channel.delete().catch(console.error), 2000)
            }, 20000)
        }
    
        /**
         * Fecha o ticket atual
         * @param {Interaction} interaction
         */
        async closeTicket(interaction) {
            const { channel, guild, user } = interaction
            const topicParts = channel.topic ? channel.topic.split('-') : []
            const userId = topicParts[2]
    
            if (!userId) {
                return interaction.reply({ content: 'Não foi possível identificar o proprietário deste ticket.', ephemeral: true })
            }
    
            const ticketOwner = guild.members.cache.get(userId)
    
            if (!ticketOwner) {
                return interaction.reply({
                    content: `${user}, o dono do ticket saiu do servidor. Aguarde um administrador deletar o ticket manualmente.`,
                    ephemeral: true
                })
            }
    
            if (!channel.permissionsFor(userId).has(PermissionsBitField.Flags.ViewChannel)) {
                return interaction.reply({ content: 'Esse ticket já está fechado!', ephemeral: true })
            }
    
            try {
                await channel.permissionOverwrites.edit(userId, { ViewChannel: false })
            } catch (error) {
                console.error(error)
                return interaction.reply(`${user.username}, algo deu errado ao fechar esse ticket.`)
            }
    
            const deleteButton = new ButtonBuilder()
                .setLabel('Deletar ticket')
                .setEmoji('🗑️')
                .setCustomId('deleteTicket')
                .setStyle(ButtonStyle.Danger)
    
            const actionRow = new ActionRowBuilder().addComponents(deleteButton)
    
            const embed = new EmbedBuilder()
                .setDescription(`O ticket foi fechado por ${user}`)
                .setColor('#FF0000')
    
            // Desabilita o botão de fechar
            const disabledCloseButton = new ButtonBuilder(interaction.message.components[0].components[0].data)
                .setDisabled(true)
    
            const disabledRow = new ActionRowBuilder().addComponents(disabledCloseButton)
    
            await interaction.message.edit({ components: [disabledRow] })
            await interaction.reply({ embeds: [embed], components: [actionRow] })
    
            // Log do fechamento
            const logEmbed = embedLogsTicket(interaction, channel.name, 'Fechado', '#ffff00')
            await guild.channels.cache.get(ticketConfig.logsChannel)?.send({ embeds: [logEmbed] })
        }
    
        /**
         * Deleta o ticket atual após confirmação
         * @param {Interaction} interaction
         */
        async deleteTicket(interaction) {
            const { guild, member, channel } = interaction
    
            // Verifica permissões
            const hasPermission = member.permissions.has(PermissionsBitField.Flags.Administrator) ||
                member.roles.cache.some(role => ticketConfig.staffRoles.includes(role.id))
    
            if (!hasPermission) {
                return interaction.reply({ content: 'Você precisa de permissão para executar esse comando.', ephemeral: true })
            }
    
            // Desabilita o botão de deletar
            const disabledDeleteButton = new ButtonBuilder(interaction.message.components[0].components[0].data)
                .setDisabled(true)
    
            const disabledRow = new ActionRowBuilder().addComponents(disabledDeleteButton)
            await interaction.message.edit({ components: [disabledRow] })
    
            await interaction.reply({ content: 'O ticket será deletado em 5 segundos.' })
    
            // Log da deleção
            const logEmbed = embedLogsTicket(interaction, channel.name, 'Deletado', '#ff0000')
            await guild.channels.cache.get(ticketConfig.logsChannel)?.send({ embeds: [logEmbed] })
    
            // Deleta o canal após 5 segundos
            setTimeout(() => {
                channel.delete().catch(console.error)
            }, 5000)
        }
    
        /**
         * Seleciona a categoria do ticket e atualiza o canal
         * @param {Interaction} interaction
         */
        async selectTicketCategory(interaction) {
            const { guild, user, values, channel } = interaction
            const selectedCategoryName = values[0].toLowerCase()
    
            const ticketCategory = ticketConfig.ticketCategories.find(cat => cat.name.toLowerCase() === selectedCategoryName)
            if (!ticketCategory) return
    
            const { category, staffRoles, name: categoryName } = ticketCategory
    
            // Verifica se o usuário já possui um ticket aberto nesta categoria
            const existingTickets = guild.channels.cache.filter(c => {
                if (c.type !== ChannelType.GuildText) return false
                if (c.parentId !== category) return false
                if (!c.topic) return false
                const [prefix, type, ticketUserId] = c.topic.split('-')
                return prefix === 'ticket' && type === categoryName.toLowerCase() && ticketUserId === user.id
            })
    
            if (existingTickets.size > 0) {
                return interaction.reply({ content: 'Você já tem um ticket dessa categoria aberto!', ephemeral: true })
            }
    
            // Atualiza as informações do canal
            await channel.edit({
                name: `${categoryName}-${user.username}`,
                topic: `ticket-${categoryName}-${user.id}`,
                parent: category,
                permissionOverwrites: [
                    {
                        id: guild.id,
                        deny: [PermissionsBitField.Flags.ViewChannel]
                    },
                    {
                        id: user.id,
                        allow: defaultPermissions
                    },
                    ...staffRoles.map(roleId => ({
                        id: roleId,
                        allow: [PermissionsBitField.Flags.ViewChannel, PermissionsBitField.Flags.SendMessages, PermissionsBitField.Flags.ReadMessageHistory]
                    }))
                ]
            })
    
            const embed = new EmbedBuilder()
                .setColor('#2B2D31')
                .setDescription(`👋 Olá ${user}, tudo bem?\n\nEm breve um membro da nossa **equipe** responsável pela categoria selecionada irá te responder.\n\nDescreva com **detalhes** o motivo do seu ticket para **agilizar** o atendimento, se\nnecessário o envio de algum tipo de arquivo, envie-o antecipadamente para que\no atendimento seja realizado mais rápido.\n\n*Por favor, não marque nenhum membro da equipe nessa sala.*`)
    
            const closeButton = new ButtonBuilder()
                .setCustomId('closeTicket')
                .setLabel('Fechar ticket')
                .setEmoji('🔒')
                .setStyle(ButtonStyle.Secondary)
    
            const actionRow = new ActionRowBuilder().addComponents(closeButton)
    
            await interaction.message.edit({ embeds: [embed], components: [actionRow] })
            await interaction.deferUpdate()
    
            // Log da abertura
            const logEmbed = embedLogsTicket(interaction, `${categoryName}-${user.username}`, 'Aberto', '#00ff00')
            await guild.channels.cache.get(ticketConfig.logsChannel)?.send({ embeds: [logEmbed] })
        }
    }
    

    Principais Melhorias Implementadas:

    1. Funções Separadas:

      • handleSlashCommand: Trata os comandos de barra.
      • handleMessageComponent: Lida com diferentes tipos de componentes de mensagem.
      • openTicket, closeTicket, deleteTicket, selectTicketCategory: Cada uma dessas funções trata uma ação específica relacionada aos tickets.
    2. Tratamento de Erros:

      • Utilização de try-catch no método principal run para capturar e responder a erros inesperados.
      • Logs de erros detalhados para facilitar a depuração.
    3. Desestruturação de Objetos:

      • Facilita a obtenção de propriedades específicas dos objetos, melhorando a legibilidade.
    4. Uso de Constantes e Mapas:

      • Definição de opções para menus de seleção de forma mais clara.
      • Utilização de mapas para configurar permissões de forma dinâmica.
    5. Redução de Redundância:

      • Evita a repetição de código ao criar componentes semelhantes como botões desabilitados.
    6. Comentários e Documentação:

      • Adição de comentários e documentação para cada método, facilitando a compreensão e manutenção do código.
    7. Melhorias na Legibilidade:

      • Organização das importações.
      • Nomenclatura clara e consistente para variáveis e funções.

    Considerações Finais

    Estas melhorias tornam o código mais modular, facilitando futuras expansões e manutenções. Além disso, o tratamento de erros aprimorado e a lógica mais clara ajudam a garantir que o sistema de tickets funcione de maneira mais robusta e previsível.

    Caso precise de funcionalidades adicionais ou ajustes específicos, sinta-se à vontade para perguntar!