z7oqi

make a command where /whenboosts (amount of times the person boosts) then give (role/s)

Kodari AI
KodariJul 28 at 6:29 pm 4
BoostMilestones
A Discord bot that rewards members for repeated server boosts. Administrators configure the `/whenboosts` slash command with a boost count and up to five server roles. The bot records each boost cycle per member, persists counts across restarts, detects new boosts, and automatically grants every configured role when a member reaches the required number. It validates administrator permissions and role hierarchy, provides private setup responses, and stores guild rules and member progress in a local properties file without requiring a database or external hosting service.
Kodari can make mistakes. Review important code before using.
Files
src
build.gradle
manifest.kod
settings.gradle
Code
8 435
src/main/java/com/kodari/boostmilestones/BoostMilestonesListener.java
package com.kodari.boostmilestones;

import net.dv8tion.jda.api.Permission;
import net.dv8tion.jda.api.entities.Guild;
import net.dv8tion.jda.api.entities.Member;
import net.dv8tion.jda.api.entities.Role;
import net.dv8tion.jda.api.entities.User;
import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
import net.dv8tion.jda.api.events.guild.member.update.GuildMemberUpdateBoostTimeEvent;
import net.dv8tion.jda.api.hooks.ListenerAdapter;
import net.dv8tion.jda.api.interactions.commands.OptionMapping;
import net.dv8tion.jda.api.interactions.commands.build.CommandData;
import net.dv8tion.jda.api.interactions.commands.build.Commands;
import net.dv8tion.jda.api.interactions.commands.build.OptionData;
import net.dv8tion.jda.api.interactions.commands.OptionType;

import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import java.util.logging.Logger;

public final class BoostMilestonesListener extends ListenerAdapter {
    private static final Logger LOGGER = Logger.getLogger(BoostMilestonesListener.class.getName());
    private final BoostStore store;

    public BoostMilestonesListener(BoostStore store) {
        this.store = store;
    }

    public static CommandData commandData() {
        return Commands.slash(
                "whenboosts",
                "Give roles after a member reaches a boost count."
            )
            .addOptions(
                new OptionData(
                    OptionType.INTEGER,
                    "amount",
                    "The number of boost cycles required.",
                    true
                ).setMinValue(1).setMaxValue(1000),
                new OptionData(
                    OptionType.ROLE,
                    "role1",
                    "The first role to give.",
                    true
                ),
                new OptionData(
                    OptionType.ROLE,
                    "role2",
                    "An additional role to give.",
                    false
                ),
                new OptionData(
                    OptionType.ROLE,
                    "role3",
                    "An additional role to give.",
                    false
                ),
                new OptionData(
                    OptionType.ROLE,
                    "role4",
                    "An additional role to give.",
                    false
                ),
                new OptionData(
                    OptionType.ROLE,
                    "role5",
                    "An additional role to give.",
                    false
                )
            );
    }

    @Override
    public void onSlashCommandInteraction(SlashCommandInteractionEvent event) {
        if (!event.getName().equals("whenboosts")) {
            return;
        }

        if (!event.isFromGuild()) {
            event.reply("This command can only be used inside a server.")
                .setEphemeral(true)
                .queue();
            return;
        }

        Member member = event.getMember();

        if (member == null
            || (!member.hasPermission(Permission.MANAGE_SERVER)
                && !member.hasPermission(Permission.ADMINISTRATOR))) {
            event.reply("You need the Manage Server permission to configure boost rewards.")
                .setEphemeral(true)
                .queue();
            return;
        }

        Guild guild = event.getGuild();

        if (guild == null) {
            return;
        }

        if (!guild.getSelfMember().hasPermission(Permission.MANAGE_ROLES)) {
            event.reply("I need the Manage Roles permission before boost rewards can be configured.")
                .setEphemeral(true)
                .queue();
            return;
        }

        int amount = event.getOption("amount").getAsInt();
        Set<Long> roleIds = new LinkedHashSet<>();

        for (int index = 1; index <= 5; index++) {
            OptionMapping option = event.getOption("role" + index);

            if (option != null) {
                Role role = option.getAsRole();

                if (role.isManaged()) {
                    event.reply("Managed integration roles cannot be assigned by the bot.")
                        .setEphemeral(true)
                        .queue();
                    return;
                }

                if (!guild.getSelfMember().canInteract(role)) {
                    event.reply("I cannot assign " + role.getAsMention()
                            + " because it is above my highest role.")
                        .setEphemeral(true)
                        .queue();
                    return;
                }

                roleIds.add(role.getIdLong());
            }
        }

        BoostRule rule = new BoostRule(amount, new ArrayList<>(roleIds));
        store.setRule(guild.getIdLong(), rule);

        event.reply("Configured boost rewards: members receive "
                + roleMentions(guild, rule.roleIds())
                + " after " + amount + " boost cycle"
                + (amount == 1 ? "" : "s") + ".")
            .setEphemeral(true)
            .queue();
    }

    @Override
    public void onGuildMemberUpdateBoostTime(GuildMemberUpdateBoostTimeEvent event) {
        Member member = event.getMember();
        boolean currentlyBoosting = member.getTimeBoosted() != null;

        BoostStore.BoostResult result = store.updateBoostState(
            event.getGuild().getIdLong(),
            member.getIdLong(),
            currentlyBoosting
        );

        if (!result.startedBoosting()) {
            return;
        }

        BoostRule rule = store.getRule(event.getGuild().getIdLong());

        if (rule == null || result.count() < rule.threshold()) {
            return;
        }

        for (long roleId : rule.roleIds()) {
            Role role = event.getGuild().getRoleById(roleId);

            if (role == null || role.isManaged() || !event.getGuild().getSelfMember().canInteract(role)) {
                continue;
            }

            event.getGuild().addRoleToMember(member, role).queue(
                ignored -> {
                },
                error -> LOGGER.warning(
                    "Unable to give role " + role.getId() + " to user " + member.getId()
                        + ": " + error.getMessage()
                )
            );
        }
    }

    private String roleMentions(Guild guild, List<Long> roleIds) {
        List<String> mentions = new ArrayList<>();

        for (long roleId : roleIds) {
            Role role = guild.getRoleById(roleId);

            if (role != null) {
                mentions.add(role.getAsMention());
            }
        }