refactor: helpthreadstats and helpthreadlistener

utf code with actual emojis for clarity,
break onSlash handler into more helpers
update helpthreadlistener to only store
true participant count in database

Author: ankitsmt211

application/src/main/java/org/togetherjava/tjbot/features/help/HelpThreadLifecycleListener.java

@@ -96,8 +96,14 @@ void handleArchiveStatus(Instant closedAt, long id, JDA jda) {
         }
 
         long threadId = threadChannel.getIdLong();
-        int messageCount = threadChannel.getMessageCount();
-        int participantsExceptAuthor = threadChannel.getMemberCount() - 1;
+        int messageCount = threadChannel.getMessageCount(); // TODO: to be replaced with participant
+                                                            // message count
+        long threadOwnerId = threadChannel.getOwnerIdLong();
+        int participantsExceptAuthor = (int) threadChannel.getMembers()
+            .stream()
+            .filter(threadMember -> threadMember.getIdLong() != threadOwnerId)
+            .filter(m -> !m.getUser().isBot())
+            .count();
 
         database.write(context -> context.update(HELP_THREADS)
             .set(HELP_THREADS.CLOSED_AT, closedAt)
@@ -131,7 +137,7 @@ private void handleTagsUpdate(long threadId, String updatedTag) {
 
     /**
      * will ignore updated tag event if all new tags belong to the categories config
-     * 
+     *
      * @param event updated tags event
      * @return boolean
      */

application/src/main/java/org/togetherjava/tjbot/features/help/HelpThreadStatsCommand.java

@@ -7,20 +7,23 @@
 import net.dv8tion.jda.api.interactions.commands.OptionMapping;
 import net.dv8tion.jda.api.interactions.commands.OptionType;
 import net.dv8tion.jda.api.interactions.commands.build.OptionData;
-import org.jooq.DSLContext;
 import org.jooq.Field;
 import org.jooq.OrderField;
+import org.jooq.Record;
 import org.jooq.Record1;
 
 import org.togetherjava.tjbot.db.Database;
 import org.togetherjava.tjbot.features.CommandVisibility;
 import org.togetherjava.tjbot.features.SlashCommandAdapter;
 
+import javax.annotation.Nullable;
+
 import java.awt.Color;
 import java.time.Duration;
 import java.time.Instant;
 import java.time.temporal.ChronoUnit;
 import java.util.Objects;
+import java.util.Optional;
 
 import static org.jooq.impl.DSL.avg;
 import static org.jooq.impl.DSL.count;
@@ -56,11 +59,11 @@ public class HelpThreadStatsCommand extends SlashCommandAdapter {
     private static final String MINIMUM_THREAD_DURATION_IN_SECONDS_ALIAS = "min_sec";
     private static final String MAXIMUM_THREAD_DURATION_IN_SECONDS_ALIAS = "max_sec";
 
-    private static final String EMOJI_CHART = "\uD83D\uDCCA";
-    private static final String EMOJI_MEMO = "\uD83D\uDCDD";
-    private static final String EMOJI_SPEECH_BUBBLE = "\uD83D\uDCAC";
-    private static final String EMOJI_LABEL = "\uD83C\uDFF7\uFE0F";
-    private static final String EMOJI_LIGHTNING = "\u26A1";
+    private static final String EMOJI_CHART = "📊";
+    private static final String EMOJI_MEMO = "📝";
+    private static final String EMOJI_SPEECH_BUBBLE = "💬";
+    private static final String EMOJI_LABEL = "🏷️";
+    private static final String EMOJI_LIGHTNING = "⚡";
 
     private static final String EMBED_BLANK_LINE = "\u200B";
     private static final String WHITESPACE = " ";
@@ -94,32 +97,19 @@ public HelpThreadStatsCommand(Database database) {
                 Caffeine.newBuilder().maximumSize(500).expireAfterWrite(COOLDOWN_DURATION).build();
     }
 
-    @Override
-    public void onSlashCommand(SlashCommandInteractionEvent event) {
-        long channelId = event.getChannel().getIdLong();
-        Instant now = Instant.now();
-
+    private long getSecondsSinceLastUsage(long channelId, Instant now) {
+        long secondsSinceLastUsage = 0;
         Instant lastUsage = this.cooldownCache.getIfPresent(channelId);
         if (lastUsage != null) {
             Duration elapsed = Duration.between(lastUsage, now);
             // to avoid displaying -1 when elapsed just crosses cooldown
-            long secondsLeft = Math.max(0, COOLDOWN_DURATION.minus(elapsed).toSeconds());
-
-            event
-                .reply("This command is on cooldown! Please wait " + secondsLeft + " more seconds.")
-                .setEphemeral(true)
-                .queue();
-            return;
+            secondsSinceLastUsage = Math.max(0, COOLDOWN_DURATION.minus(elapsed).toSeconds());
         }
+        return secondsSinceLastUsage;
+    }
 
-        cooldownCache.put(channelId, now);
-
-        long days = event.getOption(DURATION_OPTION, 1L, OptionMapping::getAsLong);
-        Instant startDate = Instant.now().minus(days, ChronoUnit.DAYS);
-
-        event.deferReply().queue();
-
-        database.read(context -> {
+    private Optional<Record> getHelpThreadUsageStats(Instant statsDurationStartDate) {
+        return database.read(context -> {
             var statsRecord = context
                 .select(count().as(TOTAL_CREATED_FIELD), count()
                     .filterWhere(
@@ -129,108 +119,157 @@ public void onSlashCommand(SlashCommandInteractionEvent event) {
                         avg(HELP_THREADS.PARTICIPANTS).as(AVERAGE_PARTICIPANTS_ALIAS),
                         avg(HELP_THREADS.MESSAGE_COUNT).as(AVERAGE_MESSAGE_COUNT_ALIAS),
                         avg(durationInSeconds(HELP_THREADS.CLOSED_AT, HELP_THREADS.CREATED_AT))
+                            .filterWhere(HELP_THREADS.PARTICIPANTS.gt(0))
                             .as(AVERAGE_THREAD_DURATION_IN_SECONDS_ALIAS),
                         min(durationInSeconds(HELP_THREADS.CLOSED_AT, HELP_THREADS.CREATED_AT))
+                            .filterWhere(HELP_THREADS.PARTICIPANTS.gt(0))
                             .as(MINIMUM_THREAD_DURATION_IN_SECONDS_ALIAS),
                         max(durationInSeconds(HELP_THREADS.CLOSED_AT, HELP_THREADS.CREATED_AT))
+                            .filterWhere(HELP_THREADS.PARTICIPANTS.gt(0))
                             .as(MAXIMUM_THREAD_DURATION_IN_SECONDS_ALIAS))
                 .from(HELP_THREADS)
-                .where(HELP_THREADS.CREATED_AT.ge(startDate))
+                .where(HELP_THREADS.CREATED_AT.ge(statsDurationStartDate))
                 .fetchOne();
 
             if (statsRecord == null || statsRecord.get(TOTAL_CREATED_FIELD, Integer.class) == 0) {
-                event.getHook()
-                    .editOriginal("No stats available for the last " + days + " days.")
-                    .queue();
-                return null;
+                return Optional.empty();
             }
+            return Optional.of(statsRecord);
+        });
+    }
+
+    private record StatsReportData(long days, int totalCreated, int openThreads, long ghostThreads,
+            double responseRate, String highVolumeTag, String highActivityTag,
+            String lowActivityTag, String peakHourRange, Record rawStats
 
-            int totalCreated = statsRecord.get(TOTAL_CREATED_FIELD, Integer.class);
-            int openThreads = statsRecord.get(OPEN_NOW_ALIAS, Integer.class);
-            long ghostThreads = statsRecord.get(GHOST_NOW_ALIAS, Number.class).longValue();
+    ) {
+    }
+
+    private EmbedBuilder buildStatsEmbed(StatsReportData helpThreadStatsResults,
+            String guildIconUrl, int daysBack) {
+        EmbedBuilder helpThreadStatsEmbed = new EmbedBuilder()
+            .setTitle(EMOJI_CHART + " Help Thread Stats (Last " + daysBack + " Days)")
+            .setColor(getStatusColor(helpThreadStatsResults.totalCreated(),
+                    helpThreadStatsResults.ghostThreads()))
+            .setTimestamp(Instant.now())
+            .setDescription(EMBED_BLANK_LINE)
+            .setFooter("Together Java Community Stats", guildIconUrl);
+
+        helpThreadStatsEmbed.addField(EMOJI_MEMO + WHITESPACE + "THREAD ACTIVITY",
+                "Created: `%d`%nCurrently Open: `%d`%nResponse Rate: %.1f%%%nPeak Hours: `%s`"
+                    .formatted(helpThreadStatsResults.totalCreated(),
+                            helpThreadStatsResults.openThreads(),
+                            helpThreadStatsResults.responseRate(),
+                            helpThreadStatsResults.peakHourRange()),
+                false);
+
+        helpThreadStatsEmbed.addField(EMOJI_SPEECH_BUBBLE + WHITESPACE + "ENGAGEMENT",
+                "Avg Messages: `%s`%nAvg Helpers: `%s`%nUnanswered (Ghost): `%d`".formatted(
+                        formatDouble(Objects.requireNonNull(helpThreadStatsResults.rawStats()
+                            .get(AVERAGE_MESSAGE_COUNT_ALIAS))),
+                        formatDouble(Objects.requireNonNull(
+                                helpThreadStatsResults.rawStats().get(AVERAGE_PARTICIPANTS_ALIAS))),
+                        helpThreadStatsResults.ghostThreads),
+                false);
+
+        helpThreadStatsEmbed.addField(EMOJI_LABEL + WHITESPACE + "TAG ACTIVITY",
+                "Most Used: `%s`%nMost Active: `%s`%nNeeds Love: `%s`".formatted(
+                        helpThreadStatsResults.highVolumeTag(),
+                        helpThreadStatsResults.highActivityTag(),
+                        helpThreadStatsResults.lowActivityTag()),
+                false);
+
+        helpThreadStatsEmbed.addField(EMOJI_LIGHTNING + WHITESPACE + "RESOLUTION SPEED",
+                "Average: `%s`%nFastest: `%s`%nSlowest: `%s`".formatted(
+                        smartFormat(helpThreadStatsResults.rawStats()
+                            .get(AVERAGE_THREAD_DURATION_IN_SECONDS_ALIAS, Double.class)),
+                        smartFormat(helpThreadStatsResults.rawStats()
+                            .get(MINIMUM_THREAD_DURATION_IN_SECONDS_ALIAS, Double.class)),
+                        smartFormat(helpThreadStatsResults.rawStats()
+                            .get(MAXIMUM_THREAD_DURATION_IN_SECONDS_ALIAS, Double.class))),
+                false);
+        return helpThreadStatsEmbed;
+    }
 
-            double rawResRate =
+
+    @Override
+    public void onSlashCommand(SlashCommandInteractionEvent event) {
+        long channelId = event.getChannel().getIdLong();
+        Instant now = Instant.now();
+        long secondsSinceLastUsage = getSecondsSinceLastUsage(channelId, now);
+        if (secondsSinceLastUsage != 0L) {
+            event
+                .reply("This command is on cooldown! Please wait " + secondsSinceLastUsage
+                        + " more seconds.")
+                .setEphemeral(true)
+                .queue();
+            return;
+        }
+        event.deferReply().queue();
+        cooldownCache.put(channelId, now);
+        int daysBackOption = Optional.ofNullable(event.getOption(DURATION_OPTION))
+            .map(OptionMapping::getAsInt)
+            .orElse(1);
+
+        Instant startDate = Instant.now().minus(daysBackOption, ChronoUnit.DAYS);
+
+        getHelpThreadUsageStats(startDate).ifPresentOrElse(stats -> {
+            int totalCreated = stats.get(TOTAL_CREATED_FIELD, Integer.class);
+            int openThreads = stats.get(OPEN_NOW_ALIAS, Integer.class);
+            long ghostThreads = stats.get(GHOST_NOW_ALIAS, Number.class).longValue();
+
+            double helpThreadInteractionRate =
                     totalCreated > 0 ? ((double) (totalCreated - ghostThreads) / totalCreated) * 100
                             : 0;
 
-            String highVolumeTag = getTopTag(context, startDate, count().desc());
-            String highActivityTag =
-                    getTopTag(context, startDate, avg(HELP_THREADS.MESSAGE_COUNT).desc());
-            String lowActivityTag =
-                    getTopTag(context, startDate, avg(HELP_THREADS.MESSAGE_COUNT).asc());
-
-            String peakHourRange = getPeakHour(context, startDate);
-
-            EmbedBuilder embed = new EmbedBuilder()
-                .setTitle(EMOJI_CHART + " Help Thread Stats (Last " + days + " Days)")
-                .setColor(getStatusColor(totalCreated, ghostThreads))
-                .setTimestamp(Instant.now())
-                .setDescription(EMBED_BLANK_LINE)
-                .setFooter("Together Java Community Stats",
-                        Objects.requireNonNull(event.getGuild()).getIconUrl());
-
-            embed.addField(EMOJI_MEMO + WHITESPACE + "THREAD ACTIVITY",
-                    "Created: `%d`%nCurrently Open: `%d`%nResponse Rate: %.1f%%%nPeak Hours: `%s`"
-                        .formatted(totalCreated, openThreads, rawResRate, peakHourRange),
-                    false);
-
-            embed.addField(EMOJI_SPEECH_BUBBLE + WHITESPACE + "ENGAGEMENT",
-                    "Avg Messages: `%s`%nAvg Helpers: `%s`%nUnanswered (Ghost): `%d`".formatted(
-                            formatDouble(Objects
-                                .requireNonNull(statsRecord.get(AVERAGE_MESSAGE_COUNT_ALIAS))),
-                            formatDouble(Objects
-                                .requireNonNull(statsRecord.get(AVERAGE_PARTICIPANTS_ALIAS))),
-                            ghostThreads),
-                    false);
-
-            embed.addField(EMOJI_LABEL + WHITESPACE + "TAG ACTIVITY",
-                    "Most Used: `%s`%nMost Active: `%s`%nNeeds Love: `%s`".formatted(highVolumeTag,
-                            highActivityTag, lowActivityTag),
-                    false);
-
-            embed.addField(EMOJI_LIGHTNING + WHITESPACE + "RESOLUTION SPEED",
-                    "Average: `%s`%nFastest: `%s`%nSlowest: `%s`".formatted(
-                            smartFormat(statsRecord.get(AVERAGE_THREAD_DURATION_IN_SECONDS_ALIAS,
-                                    Double.class)),
-                            smartFormat(statsRecord.get(MINIMUM_THREAD_DURATION_IN_SECONDS_ALIAS,
-                                    Double.class)),
-                            smartFormat(statsRecord.get(MAXIMUM_THREAD_DURATION_IN_SECONDS_ALIAS,
-                                    Double.class))),
-                    false);
-
-            event.getHook().editOriginalEmbeds(embed.build()).queue();
-            return null;
-        });
+            String highVolumeTag = getTopTag(startDate, count().desc());
+            String highActivityTag = getTopTag(startDate, avg(HELP_THREADS.MESSAGE_COUNT).desc());
+            String lowActivityTag = getTopTag(startDate, avg(HELP_THREADS.MESSAGE_COUNT).asc());
+
+            String peakHourRange = getPeakHour(startDate);
+            StatsReportData fetchedStats = new StatsReportData(daysBackOption, totalCreated,
+                    openThreads, ghostThreads, helpThreadInteractionRate, highVolumeTag,
+                    highActivityTag, lowActivityTag, peakHourRange, stats);
+            EmbedBuilder helpThreadStatsEmbed =
+                    buildStatsEmbed(fetchedStats, event.getGuild().getIconUrl(), daysBackOption);
+
+            event.getHook().editOriginalEmbeds(helpThreadStatsEmbed.build()).queue();
+
+        }, () -> event.getHook()
+            .editOriginal("No stats available for the last " + daysBackOption + " days.")
+            .queue());
     }
 
-    private static Color getStatusColor(int totalCreated, long ghostThreads) {
-        double rawResRate =
-                totalCreated > 0 ? ((double) (totalCreated - ghostThreads) / totalCreated) * 100
-                        : -1;
+    private static Color getStatusColor(int totalHelpThreadsCreated, long ghostThreads) {
+        double helpThreadInteractionRate = totalHelpThreadsCreated > 0
+                ? ((double) (totalHelpThreadsCreated - ghostThreads) / totalHelpThreadsCreated)
+                        * 100
+                : -1;
 
-        if (rawResRate >= 70)
+        if (helpThreadInteractionRate >= 70)
             return Color.GREEN;
-        if (rawResRate >= 30)
+        if (helpThreadInteractionRate >= 30)
             return Color.YELLOW;
-        if (rawResRate >= 0)
+        if (helpThreadInteractionRate >= 0)
             return Color.RED;
         return Color.GRAY;
     }
 
-    private String getTopTag(DSLContext context, Instant start, OrderField<?> order) {
-        return context.select(HELP_THREADS.TAGS)
+    private String getTopTag(Instant start, OrderField<?> order) {
+        return database.read(context -> context.select(HELP_THREADS.TAGS)
             .from(HELP_THREADS)
             .where(HELP_THREADS.CREATED_AT.ge(start))
             .and(HELP_THREADS.TAGS.ne("none"))
             .groupBy(HELP_THREADS.TAGS)
             .orderBy(order)
             .limit(1)
             .fetchOptional(HELP_THREADS.TAGS)
-            .orElse("N/A");
+            .orElse("N/A"));
     }
 
-    private String getPeakHour(DSLContext context, Instant start) {
-        return context.select(field("strftime('%H', {0})", String.class, HELP_THREADS.CREATED_AT))
+    private String getPeakHour(Instant start) {
+        return database.read(context -> context
+            .select(field("strftime('%H', {0})", String.class, HELP_THREADS.CREATED_AT))
             .from(HELP_THREADS)
             .where(HELP_THREADS.CREATED_AT.ge(start))
             .groupBy(field("strftime('%H', {0})", String.class, HELP_THREADS.CREATED_AT))
@@ -241,12 +280,14 @@ private String getPeakHour(DSLContext context, Instant start) {
                 int h = Integer.parseInt(hour);
                 return "%02d:00 - %02d:00 UTC".formatted(h, (h + 1) % 24);
             })
-            .orElse("N/A");
+            .orElse("N/A"));
     }
 
-    private String smartFormat(Double seconds) {
-        if (seconds < 0)
+    private String smartFormat(@Nullable Double seconds) {
+        if (seconds == null || seconds < 0) {
             return "N/A";
+        }
+
         if (seconds < 60)
             return "%.0f secs".formatted(seconds);
         if (seconds < 3600)
@@ -256,6 +297,7 @@ private String smartFormat(Double seconds) {
         return "%.1f days".formatted(seconds / 86400.0);
     }
 
+
     private String formatDouble(Object val) {
         return val instanceof Number num ? "%.2f".formatted(num.doubleValue()) : "0.00";
     }