Examples with MessageContextInteractionEvent net.dv8tion.jda.api.events.interaction.command.MessageContextInteractionEvent used on opensource projects

Example 1 with MessageContextInteractionEvent

use of net.dv8tion.jda.api.events.interaction.command.MessageContextInteractionEvent in project Discord-Core-Bot-Apple by demodude4u.

the class DiscordBot method startUp.

@Override
protected void startUp() throws Exception {
    info.addTechnology("[DCBA](https://github.com/demodude4u/Discord-Core-Bot-Apple)", Optional.empty(), "Discord Core Bot Apple");
    info.addTechnology("[JDA](https://github.com/DV8FromTheWorld/JDA)", Optional.of("5.0 alpha"), "Java Discord API");
    if (configJson.has("command_prefix")) {
        setCommandPrefix(Optional.of(configJson.getString("command_prefix")));
    }
    JDABuilder builder = // 
    JDABuilder.createDefault(configJson.getString("bot_token")).setEnableShutdownHook(// 
    false).addEventListeners(new ListenerAdapter() {

        @Override
        public void onCommandAutoCompleteInteraction(CommandAutoCompleteInteractionEvent event) {
            SlashCommandDefinition commandDefinition = commandSlash.get(event.getCommandPath());
            Optional<AutoCompleteHandler> autoCompleteHandler = commandDefinition.getAutoCompleteHandler();
            if (autoCompleteHandler.isPresent()) {
                AutoCompleteEvent autoCompleteEvent = new AutoCompleteEvent(event);
                autoCompleteHandler.get().handleAutoComplete(autoCompleteEvent);
            }
        }

        @Override
        public void onMessageContextInteraction(MessageContextInteractionEvent event) {
            MessageCommandDefinition commandDefinition = commandMessage.get(event.getName());
            boolean ephemeral = commandDefinition.hasRestriction(CommandRestriction.EPHEMERAL);
            CommandReporting reporting = createReporting(event);
            InteractionHook hook = event.deferReply(ephemeral).complete();
            MessageCommandEvent commandEvent = new MessageCommandEvent(event, reporting, hook, ephemeral);
            commandService.submit(() -> {
                try {
                    commandDefinition.getHandler().handleCommand(commandEvent);
                } catch (Exception e) {
                    reporting.addException(e);
                } finally {
                    if (!commandDefinition.hasRestriction(CommandRestriction.NO_REPORTING)) {
                        submitReport(reporting);
                    }
                    if (!reporting.getExceptions().isEmpty()) {
                        commandEvent.replyEmbed(new EmbedBuilder().setColor(Color.red).appendDescription("Sorry, there was a problem completing your request.\n" + reporting.getExceptions().stream().map(e -> "`" + e.getMessage() + "`").distinct().collect(Collectors.joining("\n"))).build());
                    }
                    if (!commandEvent.hasReplied()) {
                        hook.deleteOriginal().complete();
                    }
                }
            });
        }

        @Override
        public void onMessageDelete(MessageDeleteEvent event) {
            if (textWatcher.isPresent()) {
                textWatcher.get().deletedMessage(event);
            }
        }

        @Override
        public void onMessageReactionAdd(MessageReactionAddEvent event) {
            if (reactionWatcher.isPresent()) {
                reactionWatcher.get().seenReaction(event);
            }
        }

        @Override
        public void onMessageReactionRemove(MessageReactionRemoveEvent event) {
            if (reactionWatcher.isPresent()) {
                reactionWatcher.get().seenReactionRemoved(event);
            }
        }

        @Override
        public void onMessageReactionRemoveAll(MessageReactionRemoveAllEvent event) {
            if (reactionWatcher.isPresent()) {
                reactionWatcher.get().seenAllReactionRemoved(event);
            }
        }

        @Override
        public void onMessageReceived(MessageReceivedEvent event) {
            if (textWatcher.isPresent()) {
                textWatcher.get().seenMessage(event);
            }
            Message message = event.getMessage();
            MessageChannel channel = message.getChannel();
            String rawContent = message.getContentRaw().trim();
            String mentionMe = "<@!" + event.getJDA().getSelfUser().getId() + ">";
            // String mentionMe = event.getJDA().getSelfUser().getAsMention();
            boolean isPrivateChannel = channel instanceof PrivateChannel;
            if (isPrivateChannel && ignorePrivateChannels) {
                return;
            }
            boolean startsWithMentionMe = message.getMentionedUsers().stream().anyMatch(u -> u.getIdLong() == event.getJDA().getSelfUser().getIdLong()) && rawContent.startsWith(mentionMe);
            if (startsWithMentionMe) {
                rawContent = rawContent.substring(mentionMe.length()).trim();
            }
            Optional<String> effectivePrefix = getOldCommandPrefix(event);
            boolean startsWithCommandPrefix = effectivePrefix.isPresent() && rawContent.startsWith(effectivePrefix.get());
            if (startsWithCommandPrefix) {
                rawContent = rawContent.substring(effectivePrefix.get().length()).trim();
            }
            if (!event.getAuthor().isBot() && (isPrivateChannel || startsWithMentionMe || startsWithCommandPrefix)) {
                String[] split = rawContent.split("\\s+");
                if (split.length > 0) {
                    String command = split[0];
                    SlashCommandDefinition commandDefinition = commandLegacy.get(command.toLowerCase());
                    if (commandDefinition != null) {
                        boolean isPermitted = checkPermitted(channel, event.getMember(), commandDefinition);
                        if (isPermitted) {
                            event.getChannel().sendMessageEmbeds(new EmbedBuilder().appendDescription("Please use /" + commandDefinition.getPath().replace("/", " ")).build()).complete();
                        }
                    }
                }
            }
        }

        @Override
        public void onMessageUpdate(MessageUpdateEvent event) {
            if (textWatcher.isPresent()) {
                textWatcher.get().editedMessage(event);
            }
        }

        @Override
        public void onSlashCommandInteraction(SlashCommandInteractionEvent event) {
            SlashCommandDefinition commandDefinition = commandSlash.get(event.getCommandPath());
            boolean ephemeral = commandDefinition.hasRestriction(CommandRestriction.EPHEMERAL);
            CommandReporting reporting = createReporting(event);
            InteractionHook hook = event.deferReply(ephemeral).complete();
            SlashCommandEvent commandEvent = new SlashCommandEvent(event, reporting, hook, ephemeral);
            commandService.submit(() -> {
                try {
                    commandDefinition.getHandler().handleCommand(commandEvent);
                } catch (Exception e) {
                    System.err.println("Uncaught Exception!");
                    e.printStackTrace();
                    reporting.addException(e);
                } finally {
                    if (!commandDefinition.hasRestriction(CommandRestriction.NO_REPORTING)) {
                        submitReport(reporting);
                    }
                    if (!reporting.getExceptions().isEmpty()) {
                        commandEvent.replyEmbed(new EmbedBuilder().setColor(Color.red).appendDescription("Sorry, there was a problem completing your request.\n" + reporting.getExceptions().stream().map(e -> "`" + e.getMessage() + "`").distinct().collect(Collectors.joining("\n"))).build());
                    }
                    if (!commandEvent.hasReplied()) {
                        hook.deleteOriginal().complete();
                    }
                }
            });
        }
    });
    if (customSetup != null) {
        builder = customSetup.apply(builder);
    }
    jda = builder.build().awaitReady();
    jda.setRequiredScopes("bot", "applications.commands");
    reportingUserID = Optional.ofNullable(configJson.optString("reporting_user_id", null));
    reportingChannelID = Optional.ofNullable(configJson.optString("reporting_channel_id", null));
    if (configJson.has("debug_guild_commands")) {
        String guildId = configJson.getString("debug_guild_commands");
        Guild guild = jda.getGuildById(guildId);
        CommandListUpdateAction updateCommands = guild.updateCommands();
        buildUpdateCommands(updateCommands);
        updateCommands.queue();
    }
    CommandListUpdateAction updateCommands = jda.updateCommands();
    buildUpdateCommands(updateCommands);
    updateCommands.queue();
}

Example 2 with MessageContextInteractionEvent

use of net.dv8tion.jda.api.events.interaction.command.MessageContextInteractionEvent in project Bean by Xirado.

the class InteractionCommandHandler method handleMessageContextCommand.

public void handleMessageContextCommand(@NotNull MessageContextInteractionEvent event) {
    if (!event.isFromGuild())
        return;
    Guild guild = event.getGuild();
    Member member = event.getMember();
    MessageContextCommand command = null;
    if (registeredGuildCommands.containsKey(guild.getIdLong())) {
        List<MessageContextCommand> guildCommands = registeredGuildCommands.get(guild.getIdLong()).stream().filter(cmd -> cmd instanceof MessageContextCommand).map(cmd -> (MessageContextCommand) cmd).toList();
        MessageContextCommand guildCommand = guildCommands.stream().filter(cmd -> cmd.getData().getName().equalsIgnoreCase(event.getName())).findFirst().orElse(null);
        if (guildCommand != null)
            command = guildCommand;
    }
    if (command == null) {
        MessageContextCommand globalCommand = getRegisteredMessageContextCommands().stream().filter(cmd -> cmd.getData().getName().equalsIgnoreCase(event.getName())).findFirst().orElse(null);
        if (globalCommand != null)
            command = globalCommand;
    }
    if (command == null)
        return;
    List<Permission> neededPermissions = command.getRequiredUserPermissions();
    List<Permission> neededBotPermissions = command.getRequiredBotPermissions();
    if (neededPermissions != null && !member.hasPermission((GuildChannel) event.getChannel(), neededPermissions)) {
        event.reply(LocaleLoader.ofGuild(guild).get("general.no_perms", String.class)).queue();
        return;
    }
    if (neededBotPermissions != null && !event.getGuild().getSelfMember().hasPermission((GuildChannel) event.getChannel(), neededBotPermissions)) {
        event.reply(LocaleLoader.ofGuild(guild).get("general.no_bot_perms1", String.class)).queue();
        return;
    }
    if (command.getCommandFlags().contains(CommandFlag.MUST_BE_IN_VC)) {
        GuildVoiceState guildVoiceState = member.getVoiceState();
        if (guildVoiceState == null || !guildVoiceState.inAudioChannel()) {
            event.replyEmbeds(EmbedUtil.errorEmbed("You are not connected to a voice-channel!")).queue();
            return;
        }
    }
    if (command.getCommandFlags().contains(CommandFlag.MUST_BE_IN_SAME_VC)) {
        GuildVoiceState voiceState = member.getVoiceState();
        AudioManager manager = event.getGuild().getAudioManager();
        if (manager.isConnected()) {
            if (!manager.getConnectedChannel().equals(voiceState.getChannel())) {
                event.replyEmbeds(EmbedUtil.errorEmbed("You must be listening in " + manager.getConnectedChannel().getAsMention() + "to do this!")).setEphemeral(true).queue();
                return;
            }
        }
    }
    MessageContextCommand finalCommand = command;
    Runnable r = () -> {
        try {
            finalCommand.executeCommand(event);
            Metrics.COMMANDS.labels("success").inc();
        } catch (Exception e) {
            Metrics.COMMANDS.labels("failed").inc();
            LinkedDataObject translation = event.getGuild() == null ? LocaleLoader.getForLanguage("en_US") : LocaleLoader.ofGuild(event.getGuild());
            if (event.isAcknowledged())
                event.getHook().sendMessageEmbeds(EmbedUtil.errorEmbed(translation.getString("general.unknown_error_occured"))).setEphemeral(true).queue(s -> {
                }, ex -> {
                });
            else
                event.replyEmbeds(EmbedUtil.errorEmbed(translation.getString("general.unknown_error_occured"))).setEphemeral(true).queue(s -> {
                }, ex -> {
                });
            LOGGER.error("Could not execute message-context-menu-command", e);
            EmbedBuilder builder = new EmbedBuilder().setTitle("An error occurred while executing a message-context-command!").addField("Guild", event.getGuild() == null ? "None (Direct message)" : event.getGuild().getIdLong() + " (" + event.getGuild().getName() + ")", true).addField("Channel", event.getGuild() == null ? "None (Direct message)" : event.getChannel().getName(), true).addField("User", event.getUser().getAsMention() + " (" + event.getUser().getAsTag() + ")", true).addField("Command", event.getName(), false).setColor(EmbedUtil.ERROR_COLOR);
            event.getJDA().openPrivateChannelById(Bean.OWNER_ID).flatMap(c -> c.sendMessageEmbeds(builder.build()).content("```fix\n" + ExceptionUtils.getStackTrace(e) + "\n```")).queue();
        }
    };
    Bean.getInstance().getCommandExecutor().submit(r);
}