Readd team and voting commands and fix the placeholders in the language files so they match the project fluent system

Author: TheZexquex

backend/src/main/java/de/chojo/pluginjam/bot/Bot.java

@@ -8,10 +8,12 @@
 
 import com.google.inject.Guice;
 import de.chojo.pluginjam.bot.commands.CommandContextProvider;
+import de.chojo.pluginjam.bot.listener.InviteButtonListener;
 import de.chojo.pluginjam.database.repository.SettingsRepository;
 import de.chojo.pluginjam.service.JamService;
 import de.chojo.pluginjam.service.SettingsService;
 import de.chojo.pluginjam.service.TeamService;
+import de.chojo.pluginjam.service.VoteService;
 import io.github.kaktushose.jdac.JDACommands;
 import io.github.kaktushose.jdac.annotations.interactions.CommandConfig;
 import io.github.kaktushose.jdac.annotations.interactions.CommandScope;
@@ -42,14 +44,16 @@ public class Bot implements ApplicationEventListener<ApplicationStartupEvent> {
     private final JamService jamService;
     private final SettingsService settingsService;
     private final TeamService teamService;
+    private final VoteService voteService;
     private final String token;
 
     private ShardManager shardManager;
 
-    public Bot(JamService jamService, SettingsService settingsService, TeamService teamService, @Value("${bot.token}") String token) {
+    public Bot(JamService jamService, SettingsService settingsService, TeamService teamService, VoteService voteService, @Value("${bot.token}") String token) {
         this.jamService = jamService;
         this.settingsService = settingsService;
         this.teamService = teamService;
+        this.voteService = voteService;
         this.token = token;
     }
 
@@ -85,7 +89,8 @@ private void buildCommands() {
         var userContextProvider = new CommandContextProvider(
                 jamService,
                 settingsService,
-                teamService
+                teamService,
+                voteService
         );
         var injector = Guice.createInjector(new BotModule(userContextProvider));
         JDACommands.builder(shardManager)
@@ -102,7 +107,7 @@ private void buildCommands() {
                     }
                 })
                 .start();
-        //shardManager.addEventListener(new InviteButtonListener(guilds));
+        shardManager.addEventListener(new InviteButtonListener(teamService, settingsService, jamService));
     }
 
     private void initBot() {

backend/src/main/java/de/chojo/pluginjam/bot/commands/CommandContextProvider.java

@@ -3,16 +3,19 @@
 import de.chojo.pluginjam.service.JamService;
 import de.chojo.pluginjam.service.SettingsService;
 import de.chojo.pluginjam.service.TeamService;
+import de.chojo.pluginjam.service.VoteService;
 
 public class CommandContextProvider {
     private final JamService jamService;
     private final SettingsService settingsService;
     private final TeamService teamService;
+    private final VoteService voteService;
 
-    public CommandContextProvider(JamService jamService, SettingsService settingsService, TeamService teamService) {
+    public CommandContextProvider(JamService jamService, SettingsService settingsService, TeamService teamService, VoteService voteService) {
         this.jamService = jamService;
         this.settingsService = settingsService;
         this.teamService = teamService;
+        this.voteService = voteService;
     }
 
     public JamService pluginJamService() {
@@ -26,4 +29,8 @@ public SettingsService settingsService() {
     public TeamService teamService() {
         return teamService;
     }
+
+    public VoteService voteService() {
+        return voteService;
+    }
 }

backend/src/main/java/de/chojo/pluginjam/bot/commands/team/TeamCreateCommand.java

@@ -102,8 +102,6 @@ public void onCommand(CommandEvent event, @Param("name") String teamName) {
                         .getIdLong(), Collections.emptySet(), EnumSet.of(Permission.VIEW_CHANNEL))
                 .complete();
 
-        //meta.token(Token.generate(40));
-
         var team = commandContextProvider.teamService().createTeam(
                 jam.id(),
                 teamName,

backend/src/main/java/de/chojo/pluginjam/bot/commands/team/TeamInviteCommand.java

@@ -0,0 +1,111 @@
+/*
+ *     SPDX-License-Identifier: AGPL-3.0-only
+ *
+ *     Copyright (C) 2022 DevCord Team and Contributor
+ */
+
+package de.chojo.pluginjam.bot.commands.team;
+
+import com.google.inject.Inject;
+import de.chojo.pluginjam.bot.commands.CommandContextProvider;
+import io.github.kaktushose.jdac.annotations.i18n.Bundle;
+import io.github.kaktushose.jdac.annotations.interactions.Command;
+import io.github.kaktushose.jdac.annotations.interactions.Interaction;
+import io.github.kaktushose.jdac.annotations.interactions.Param;
+import io.github.kaktushose.jdac.dispatching.events.interactions.CommandEvent;
+import io.github.kaktushose.jdac.message.placeholder.Entry;
+import io.github.kaktushose.jdac.message.resolver.MessageResolver;
+import net.dv8tion.jda.api.EmbedBuilder;
+import net.dv8tion.jda.api.components.Component;
+import net.dv8tion.jda.api.components.actionrow.ActionRow;
+import net.dv8tion.jda.api.components.buttons.Button;
+import net.dv8tion.jda.api.components.container.Container;
+import net.dv8tion.jda.api.components.textdisplay.TextDisplay;
+import net.dv8tion.jda.api.entities.User;
+import net.dv8tion.jda.api.interactions.commands.OptionType;
+
+@Bundle("locale")
+@Interaction
+public final class TeamInviteCommand {
+    private final CommandContextProvider commandContextProvider;
+    private final MessageResolver messageResolver;
+
+    @Inject
+    public TeamInviteCommand(CommandContextProvider commandContextProvider, MessageResolver messageResolver) {
+        this.commandContextProvider = commandContextProvider;
+        this.messageResolver = messageResolver;
+    }
+
+    @Command(value = "team invite")
+    public void onCommand(CommandEvent event, @Param(value = "user", type = OptionType.USER) User user) {
+        var guildId = event.getGuild().getIdLong();
+        var optJam = commandContextProvider.pluginJamService().getCurrentOrUpcoming(guildId);
+
+        if (optJam.isEmpty()) {
+            event.with().ephemeral(true).reply("error-nojamactive");
+            return;
+        }
+        var jam = optJam.get();
+
+        if (jam.state().voting()) {
+            event.with().ephemeral(true).reply("error-votingactive");
+            return;
+        }
+
+        var optTeam = commandContextProvider.teamService().getUserTeam(event.getUser().getIdLong());
+
+        if (optTeam.isEmpty()) {
+            event.with().ephemeral(true).reply("error-noteam");
+            return;
+        }
+
+        var team = optTeam.get();
+
+        if (!team.isLeader(event.getUser())) {
+            event.with().ephemeral(true).reply("command-team-invite-message-noleader");
+            return;
+        }
+
+        var members = team.members();
+        var settings = commandContextProvider.settingsService().getSettings(guildId);
+
+        if (members.size() >= settings.getTeamSize()) {
+            event.with().ephemeral(true).reply("error-maxteamsize");
+            return;
+        }
+
+        if (jam.registrations().stream().noneMatch(r -> r.userId().equals(user.getIdLong()))) {
+            event.with().ephemeral(true).reply("command-team-invite-message-notRegistered");
+            return;
+        }
+
+        var currTeam = commandContextProvider.teamService().getUserTeam(user.getIdLong());
+
+        if (currTeam.isPresent()) {
+            event.reply("command-team-invite-message-partofteam");
+            return;
+        }
+
+        var teamId = team.id();
+        var buttonId = "invite-accept:" + guildId + ":" + teamId + ":" + user.getIdLong();
+
+        var components = Container.of(
+                TextDisplay.of(messageResolver.resolve("command-team-invite-message-invitation", event.getGuildLocale(),
+                        Entry.entry("USER", user.getAsMention()),
+                        Entry.entry("TEAM", team.meta().getTeamName()))
+                ),
+                ActionRow.of(Button.success(buttonId, messageResolver.resolve("command-team-invite-message-accept", event.getGuildLocale())))
+        );
+
+        var embed = new EmbedBuilder()
+                .setTitle("You have been invited to join a team on " + event.getGuild().getName())
+                .setDescription(event.getUser().getAsMention() + " has invited you to join team **" + team.meta().getTeamName() + "**")
+                .build();
+
+        user.openPrivateChannel().queue(channel ->
+                channel.sendMessageComponents(components).useComponentsV2().queue()
+        );
+
+        event.with().ephemeral(true).reply("command-team-invite-message-send");
+    }
+}

backend/src/main/java/de/chojo/pluginjam/bot/commands/team/TeamLeaveCommand.java

@@ -0,0 +1,56 @@
+/*
+ *     SPDX-License-Identifier: AGPL-3.0-only
+ *
+ *     Copyright (C) 2022 DevCord Team and Contributor
+ */
+
+package de.chojo.pluginjam.bot.commands.team;
+
+import com.google.inject.Inject;
+import de.chojo.pluginjam.bot.commands.CommandContextProvider;
+import io.github.kaktushose.jdac.annotations.i18n.Bundle;
+import io.github.kaktushose.jdac.annotations.interactions.Command;
+import io.github.kaktushose.jdac.annotations.interactions.Interaction;
+import io.github.kaktushose.jdac.dispatching.events.interactions.CommandEvent;
+
+@Bundle("locale")
+@Interaction
+public final class TeamLeaveCommand {
+    private final CommandContextProvider commandContextProvider;
+
+    @Inject
+    public TeamLeaveCommand(CommandContextProvider commandContextProvider) {
+        this.commandContextProvider = commandContextProvider;
+    }
+
+    @Command(value = "team leave")
+    public void onCommand(CommandEvent event) {
+        var guildId = event.getGuild().getIdLong();
+        var optJam = commandContextProvider.pluginJamService().getCurrentOrUpcoming(guildId);
+
+        if (optJam.isEmpty()) {
+            event.with().ephemeral(true).reply("error-nojamactive");
+            return;
+        }
+        var jam = optJam.get();
+
+        if (jam.state().voting()) {
+            event.with().ephemeral(true).reply("error-votingactive");
+            return;
+        }
+
+        var teamOpt = commandContextProvider.teamService().getUserTeam(event.getMember().getIdLong());
+        teamOpt.ifPresentOrElse((team) -> {
+            if (team.isLeader(event.getUser())) {
+                event.with().ephemeral(true).reply("command-team-leave-message-leaderleave");
+                return;
+            }
+
+            commandContextProvider.teamService().leaveTeam(team, event.getMember(), event.getGuild());
+            event.with().ephemeral(true).reply("command-team-leave-left");
+            event.getGuild().getTextChannelById(team.meta().getTextChannelId()).sendMessage("command-team-leave-message-left").queue();
+        }, () -> {
+            event.with().ephemeral(true).reply("error-noteam");
+        });
+    }
+}

backend/src/main/java/de/chojo/pluginjam/bot/commands/team/TeamListCommand.java

@@ -0,0 +1,125 @@
+    /*
+     *     SPDX-License-Identifier: AGPL-3.0-only
+     *
+     *     Copyright (C) 2022 DevCord Team and Contributor
+     */
+
+    package de.chojo.pluginjam.bot.commands.team;
+
+    import com.google.inject.Inject;
+    import de.chojo.pluginjam.bot.commands.CommandContextProvider;
+    import de.chojo.pluginjam.bot.message.DefaultValues;
+    import de.chojo.pluginjam.bot.util.MentionUtil;
+    import de.chojo.pluginjam.database.entity.team.Team;
+    import io.github.kaktushose.jdac.annotations.i18n.Bundle;
+    import io.github.kaktushose.jdac.annotations.interactions.Button;
+    import io.github.kaktushose.jdac.annotations.interactions.Command;
+    import io.github.kaktushose.jdac.annotations.interactions.Interaction;
+    import io.github.kaktushose.jdac.dispatching.events.interactions.CommandEvent;
+    import io.github.kaktushose.jdac.dispatching.events.interactions.ComponentEvent;
+    import io.github.kaktushose.jdac.dispatching.reply.Component;
+    import io.github.kaktushose.jdac.message.resolver.MessageResolver;
+    import net.dv8tion.jda.api.components.actionrow.ActionRow;
+    import net.dv8tion.jda.api.components.buttons.ButtonStyle;
+    import net.dv8tion.jda.api.components.container.Container;
+    import net.dv8tion.jda.api.components.container.ContainerChildComponent;
+    import net.dv8tion.jda.api.components.textdisplay.TextDisplay;
+    import net.dv8tion.jda.api.interactions.DiscordLocale;
+
+    import java.util.List;
+    import java.util.UUID;
+    import java.util.stream.Collectors;
+
+    @Bundle("locale")
+    @Interaction
+    public class TeamListCommand {
+        private final CommandContextProvider commandContextProvider;
+        private final MessageResolver messageResolver;
+
+        private List<Team> pageEntries;
+        private int currentPage;
+
+        @Inject
+        public TeamListCommand(CommandContextProvider commandContextProvider, MessageResolver messageResolver) {
+            this.commandContextProvider = commandContextProvider;
+            this.messageResolver = messageResolver;
+        }
+
+        @Command(value = "team list")
+        public void onCommand(CommandEvent event) {
+            var guildId = event.getGuild().getIdLong();
+            var optJam = commandContextProvider.pluginJamService().getCurrentOrUpcoming(guildId);
+
+            if (optJam.isEmpty()) {
+                event.with().ephemeral(true).reply("error-nojamactive");
+                return;
+            }
+            var jam = optJam.get();
+
+            pageEntries = commandContextProvider.teamService().getTeamsByJamId(jam.id());
+
+            currentPage = 0;
+            event.with().ephemeral(true).reply(renderPage(0, pageEntries, event.getUserLocale()));
+        }
+
+        private Container renderPage(int page, List<Team> entries, DiscordLocale locale) {
+            int pageSize = 1;
+
+            boolean hasNext = page < (entries.size() - 1) / pageSize;
+            boolean hasPrev = page > 0;
+
+            int start = page * pageSize;
+            int end = Math.min(start + pageSize, entries.size());
+
+            List<ContainerChildComponent> teamContents = entries.subList(start, end).stream().map(team -> {
+                var membersContent = team.members()
+                        .stream()
+                        .map(teamMember -> String.format("- %s", MentionUtil.user(teamMember.userId())))
+                        .collect(Collectors.joining(" \n"));
+
+                var contentString = """
+                        # %s (%s)
+                        ### %s:
+                        *%s*
+                        ### %s:
+                        *%s*
+                        ### %s:
+                        *%s*
+                        """.formatted(
+                        team.meta().getTeamName(),
+                        MentionUtil.role(team.meta().getRoleId()),
+                        messageResolver.resolve("word-description", locale),
+                        DefaultValues.getTeamProjectDescription(team, messageResolver, locale),
+                        messageResolver.resolve("word-project-url", locale),
+                        DefaultValues.getTeamProjectUrl(team, messageResolver, locale),
+                        messageResolver.resolve("word-members", locale),
+                        membersContent);
+
+                return TextDisplay.of(contentString);
+            }).collect(Collectors.toList());
+
+            int maxPages = (int) Math.ceil(entries.size() / (double) pageSize);
+
+            teamContents.add(
+                    ActionRow.of(
+                            hasPrev ? Component.enabled("onPrev") : Component.disabled("onPrev"),
+                            net.dv8tion.jda.api.components.buttons.Button.of(ButtonStyle.SECONDARY, UUID.randomUUID().toString(), "%d / %d".formatted(currentPage + 1, maxPages), null),
+                            hasNext ? Component.enabled("onNext") : Component.disabled("onNext")
+                    )
+            );
+
+            return Container.of(teamContents);
+        }
+
+        @Button(value = "◀", style = ButtonStyle.SECONDARY)
+        public void onPrev(ComponentEvent event) {
+            currentPage--;
+            event.with().keepComponents(false).ephemeral(true).reply(renderPage(currentPage, pageEntries, event.getUserLocale()));
+        }
+
+        @Button(value = "▶", style = ButtonStyle.SECONDARY)
+        public void onNext(ComponentEvent event) {
+            currentPage++;
+            event.with().keepComponents(false).ephemeral(true).reply(renderPage(currentPage, pageEntries, event.getUserLocale()));
+        }
+    }