Removing some of the redundant extensions

2026-05-13 05:08:31 -05:00 · 2024-04-06 21:23:12 -05:00
parent 68bf290d1e
commit bfdf9b2ef9
8 changed files with 233 additions and 105 deletions
@@ -12,8 +12,6 @@ import org.dreamexposure.discal.core.business.AnnouncementService
 import org.dreamexposure.discal.core.business.EmbedService
 import org.dreamexposure.discal.core.crypto.KeyGenerator
 import org.dreamexposure.discal.core.enums.event.EventColor
-import org.dreamexposure.discal.core.extensions.discord4j.followup
-import org.dreamexposure.discal.core.extensions.discord4j.followupEphemeral
 import org.dreamexposure.discal.core.extensions.discord4j.getCalendar
 import org.dreamexposure.discal.core.extensions.discord4j.hasControlRole
 import org.dreamexposure.discal.core.`object`.GuildSettings
@@ -87,7 +85,9 @@ class AnnouncementCommand(

        // Validate permissions
        val hasControlRole = event.interaction.member.get().hasControlRole().awaitSingle()
-        if (!hasControlRole) return event.followup(getCommonMsg("error.perms.privileged", settings)).awaitSingle()
+        if (!hasControlRole) return event.createFollowup(getCommonMsg("error.perms.privileged", settings))
+            .withEphemeral(ephemeral)
+            .awaitSingle()

        // Check if wizard already started
        val existingWizard = announcementService.getWizard(settings.guildID, event.interaction.user.id)
@@ -128,7 +128,9 @@ class AnnouncementCommand(

        // Validate permissions
        val hasControlRole = event.interaction.member.get().hasControlRole().awaitSingle()
-        if (!hasControlRole) return event.followup(getCommonMsg("error.perms.privileged", settings)).awaitSingle()
+        if (!hasControlRole) return event.createFollowup(getCommonMsg("error.perms.privileged", settings))
+            .withEphemeral(ephemeral)
+            .awaitSingle()

        // Check if wizard not started
        val existingWizard = announcementService.getWizard(settings.guildID, event.interaction.user.id)
@@ -159,7 +161,9 @@ class AnnouncementCommand(

        // Validate permissions
        val hasControlRole = event.interaction.member.get().hasControlRole().awaitSingle()
-        if (!hasControlRole) return event.followup(getCommonMsg("error.perms.privileged", settings)).awaitSingle()
+        if (!hasControlRole) return event.createFollowup(getCommonMsg("error.perms.privileged", settings))
+            .withEphemeral(ephemeral)
+            .awaitSingle()

        // Check if wizard not started
        val existingWizard = announcementService.getWizard(settings.guildID, event.interaction.user.id)
@@ -211,7 +215,9 @@ class AnnouncementCommand(

        // Validate permissions
        val hasControlRole = event.interaction.member.get().hasControlRole().awaitSingle()
-        if (!hasControlRole) return event.followup(getCommonMsg("error.perms.privileged", settings)).awaitSingle()
+        if (!hasControlRole) return event.createFollowup(getCommonMsg("error.perms.privileged", settings))
+            .withEphemeral(ephemeral)
+            .awaitSingle()

        // Check if wizard not started
        val existingWizard = announcementService.getWizard(settings.guildID, event.interaction.user.id)
@@ -244,7 +250,9 @@ class AnnouncementCommand(

        // Validate permissions
        val hasControlRole = event.interaction.member.get().hasControlRole().awaitSingle()
-        if (!hasControlRole) return event.followup(getCommonMsg("error.perms.privileged", settings)).awaitSingle()
+        if (!hasControlRole) return event.createFollowup(getCommonMsg("error.perms.privileged", settings))
+            .withEphemeral(ephemeral)
+            .awaitSingle()

        // Check if wizard not started
        val existingWizard = announcementService.getWizard(settings.guildID, event.interaction.user.id)
@@ -271,7 +279,9 @@ class AnnouncementCommand(

        // Validate permissions
        val hasControlRole = event.interaction.member.get().hasControlRole().awaitSingle()
-        if (!hasControlRole) return event.followup(getCommonMsg("error.perms.privileged", settings)).awaitSingle()
+        if (!hasControlRole) return event.createFollowup(getCommonMsg("error.perms.privileged", settings))
+            .withEphemeral(ephemeral)
+            .awaitSingle()

        // Check if wizard not started
        val existingWizard = announcementService.getWizard(settings.guildID, event.interaction.user.id)
@@ -298,7 +308,9 @@ class AnnouncementCommand(

        // Validate permissions
        val hasControlRole = event.interaction.member.get().hasControlRole().awaitSingle()
-        if (!hasControlRole) return event.followup(getCommonMsg("error.perms.privileged", settings)).awaitSingle()
+        if (!hasControlRole) return event.createFollowup(getCommonMsg("error.perms.privileged", settings))
+            .withEphemeral(ephemeral)
+            .awaitSingle()

        // Check if wizard not started
        val existingWizard = announcementService.getWizard(settings.guildID, event.interaction.user.id)
@@ -325,7 +337,9 @@ class AnnouncementCommand(

        // Validate permissions
        val hasControlRole = event.interaction.member.get().hasControlRole().awaitSingle()
-        if (!hasControlRole) return event.followup(getCommonMsg("error.perms.privileged", settings)).awaitSingle()
+        if (!hasControlRole) return event.createFollowup(getCommonMsg("error.perms.privileged", settings))
+            .withEphemeral(ephemeral)
+            .awaitSingle()

        // Check if wizard not started
        val existingWizard = announcementService.getWizard(settings.guildID, event.interaction.user.id)
@@ -352,7 +366,9 @@ class AnnouncementCommand(

        // Validate permissions
        val hasControlRole = event.interaction.member.get().hasControlRole().awaitSingle()
-        if (!hasControlRole) return event.followup(getCommonMsg("error.perms.privileged", settings)).awaitSingle()
+        if (!hasControlRole) return event.createFollowup(getCommonMsg("error.perms.privileged", settings))
+            .withEphemeral(ephemeral)
+            .awaitSingle()

        // Check if wizard not started
        val existingWizard = announcementService.getWizard(settings.guildID, event.interaction.user.id)
@@ -378,7 +394,9 @@ class AnnouncementCommand(

        // Validate permissions
        val hasControlRole = event.interaction.member.get().hasControlRole().awaitSingle()
-        if (!hasControlRole) return event.followup(getCommonMsg("error.perms.privileged", settings)).awaitSingle()
+        if (!hasControlRole) return event.createFollowup(getCommonMsg("error.perms.privileged", settings))
+            .withEphemeral(ephemeral)
+            .awaitSingle()

        // Check if wizard not started
        val existingWizard = announcementService.getWizard(settings.guildID, event.interaction.user.id)
@@ -407,7 +425,9 @@ class AnnouncementCommand(
    private suspend fun review(event: ChatInputInteractionEvent, settings: GuildSettings): Message {
        // Validate permissions
        val hasControlRole = event.interaction.member.get().hasControlRole().awaitSingle()
-        if (!hasControlRole) return event.followup(getCommonMsg("error.perms.privileged", settings)).awaitSingle()
+        if (!hasControlRole) return event.createFollowup(getCommonMsg("error.perms.privileged", settings))
+            .withEphemeral(ephemeral)
+            .awaitSingle()

        // Check if wizard not started
        val existingWizard = announcementService.getWizard(settings.guildID, event.interaction.user.id)
@@ -424,7 +444,9 @@ class AnnouncementCommand(
    private suspend fun confirm(event: ChatInputInteractionEvent, settings: GuildSettings): Message {
        // Validate permissions
        val hasControlRole = event.interaction.member.get().hasControlRole().awaitSingle()
-        if (!hasControlRole) return event.followup(getCommonMsg("error.perms.privileged", settings)).awaitSingle()
+        if (!hasControlRole) return event.createFollowup(getCommonMsg("error.perms.privileged", settings))
+            .withEphemeral(ephemeral)
+            .awaitSingle()

        // Check if wizard not started
        val existingWizard = announcementService.getWizard(settings.guildID, event.interaction.user.id)
@@ -465,7 +487,9 @@ class AnnouncementCommand(
    private suspend fun cancel(event: ChatInputInteractionEvent, settings: GuildSettings): Message {
        // Validate permissions
        val hasControlRole = event.interaction.member.get().hasControlRole().awaitSingle()
-        if (!hasControlRole) return event.followup(getCommonMsg("error.perms.privileged", settings)).awaitSingle()
+        if (!hasControlRole) return event.createFollowup(getCommonMsg("error.perms.privileged", settings))
+            .withEphemeral(ephemeral)
+            .awaitSingle()

        announcementService.cancelWizard(settings.guildID, event.interaction.user.id)

@@ -482,7 +506,9 @@ class AnnouncementCommand(

        // Validate permissions
        val hasControlRole = event.interaction.member.get().hasControlRole().awaitSingle()
-        if (!hasControlRole) return event.followup(getCommonMsg("error.perms.privileged", settings)).awaitSingle()
+        if (!hasControlRole) return event.createFollowup(getCommonMsg("error.perms.privileged", settings))
+            .withEphemeral(ephemeral)
+            .awaitSingle()

        // Check if wizard already started
        val existingWizard = announcementService.getWizard(settings.guildID, event.interaction.user.id)
@@ -494,7 +520,9 @@ class AnnouncementCommand(
        }

        val announcement = announcementService.getAnnouncement(settings.guildID, announcementId)
-            ?: return event.followupEphemeral(getCommonMsg("error.notFound.announcement", settings)).awaitSingle()
+            ?: return event.createFollowup(getCommonMsg("error.notFound.announcement", settings))
+                .withEphemeral(true)
+                .awaitSingle()

        val newWizard = AnnouncementWizardState(
            guildId = settings.guildID,
@@ -518,7 +546,9 @@ class AnnouncementCommand(

        // Validate permissions
        val hasControlRole = event.interaction.member.get().hasControlRole().awaitSingle()
-        if (!hasControlRole) return event.followup(getCommonMsg("error.perms.privileged", settings)).awaitSingle()
+        if (!hasControlRole) return event.createFollowup(getCommonMsg("error.perms.privileged", settings))
+            .withEphemeral(ephemeral)
+            .awaitSingle()

        // Check if wizard already started
        val existingWizard = announcementService.getWizard(settings.guildID, event.interaction.user.id)
@@ -530,7 +560,9 @@ class AnnouncementCommand(
        }

        val announcement = announcementService.getAnnouncement(settings.guildID, announcementId)
-            ?: return event.followupEphemeral(getCommonMsg("error.notFound.announcement", settings)).awaitSingle()
+            ?: return event.createFollowup(getCommonMsg("error.notFound.announcement", settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()

        val newWizard = AnnouncementWizardState(
            guildId = settings.guildID,
@@ -554,7 +586,9 @@ class AnnouncementCommand(

        // Validate permissions
        val hasControlRole = event.interaction.member.get().hasControlRole().awaitSingle()
-        if (!hasControlRole) return event.followup(getCommonMsg("error.perms.privileged", settings)).awaitSingle()
+        if (!hasControlRole) return event.createFollowup(getCommonMsg("error.perms.privileged", settings))
+            .withEphemeral(ephemeral)
+            .awaitSingle()

        // If announcement is being edited, cancel the editor
        announcementService.cancelWizard(settings.guildID, announcementId)
@@ -577,10 +611,14 @@ class AnnouncementCommand(

        // Validate permissions
        val hasControlRole = event.interaction.member.get().hasControlRole().awaitSingle()
-        if (!hasControlRole) return event.followup(getCommonMsg("error.perms.privileged", settings)).awaitSingle()
+        if (!hasControlRole) return event.createFollowup(getCommonMsg("error.perms.privileged", settings))
+            .withEphemeral(ephemeral)
+            .awaitSingle()

        val announcement = announcementService.getAnnouncement(settings.guildID, announcementId)
-            ?: return event.followupEphemeral(getCommonMsg("error.notFound.announcement", settings)).awaitSingle()
+            ?: return event.createFollowup(getCommonMsg("error.notFound.announcement", settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()

        val new = announcement.copy(enabled = enabled)
        announcementService.updateAnnouncement(new)
@@ -601,7 +639,9 @@ class AnnouncementCommand(
            .get()

        val announcement = announcementService.getAnnouncement(settings.guildID, announcementId)
-            ?: return event.followupEphemeral(getCommonMsg("error.notFound.announcement", settings)).awaitSingle()
+            ?: return event.createFollowup(getCommonMsg("error.notFound.announcement", settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()

        return event.createFollowup()
            .withEphemeral(ephemeral)
@@ -637,7 +677,9 @@ class AnnouncementCommand(
            .filter { it.calendarNumber == calendar }

        return if (announcements.isEmpty()) {
-            event.followupEphemeral(getMessage("list.success.none", settings)).awaitSingle()
+            event.createFollowup(getMessage("list.success.none", settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()
        } else if (announcements.size == 1) {
            event.createFollowup()
                .withEphemeral(ephemeral)
@@ -648,10 +690,15 @@ class AnnouncementCommand(
        } else {
            val limit = if (amount > 0) amount.coerceAtMost(announcements.size) else announcements.size

-            val message = event.followupEphemeral(getMessage("list.success.many", settings, "$limit")).awaitSingle()
+            val message = event.createFollowup(getMessage("list.success.many", settings, "$limit"))
+                .withEphemeral(ephemeral)
+                .awaitSingle()

            announcements.subList(0, limit).forEach { announcement ->
-                event.followupEphemeral(embedService.condensedAnnouncementEmbed(announcement, settings)).awaitSingle()
+                event.createFollowup()
+                    .withEmbeds(embedService.condensedAnnouncementEmbed(announcement, settings))
+                    .withEphemeral(ephemeral)
+                    .awaitSingle()
            }

            message
@@ -675,7 +722,9 @@ class AnnouncementCommand(
            .getOrNull()

        val announcement = announcementService.getAnnouncement(settings.guildID, announcementId)
-            ?: return event.followupEphemeral(getCommonMsg("error.notFound.announcement", settings)).awaitSingle()
+            ?: return event.createFollowup(getCommonMsg("error.notFound.announcement", settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()

        var newSubs = announcement.subscribers
        if (userId != null) newSubs = newSubs.copy(users = newSubs.users + userId)
@@ -708,7 +757,9 @@ class AnnouncementCommand(
            .getOrNull()

        val announcement = announcementService.getAnnouncement(settings.guildID, announcementId)
-            ?: return event.followupEphemeral(getCommonMsg("error.notFound.announcement", settings)).awaitSingle()
+            ?: return event.createFollowup(getCommonMsg("error.notFound.announcement", settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()

        var newSubs = announcement.subscribers
        if (userId != null) newSubs = newSubs.copy(users = newSubs.users - userId)
@@ -7,7 +7,6 @@ import org.dreamexposure.discal.client.commands.SlashCommand
 import org.dreamexposure.discal.core.business.AnnouncementService
 import org.dreamexposure.discal.core.business.CalendarService
 import org.dreamexposure.discal.core.business.EmbedService
-import org.dreamexposure.discal.core.extensions.discord4j.followup
 import org.dreamexposure.discal.core.`object`.GuildSettings
 import org.springframework.stereotype.Component

@@ -28,6 +27,9 @@ class DiscalCommand(

        val embed = embedService.discalInfoEmbed(settings, guildCount, calendarCount, announcementCount)

-        return event.followup(embed).awaitSingle()
+        return event.createFollowup()
+            .withEmbeds(embed)
+            .withEphemeral(ephemeral)
+            .awaitSingle()
    }
 }
@@ -8,7 +8,6 @@ import kotlinx.coroutines.reactor.awaitSingle
 import kotlinx.coroutines.reactor.awaitSingleOrNull
 import org.dreamexposure.discal.client.commands.SlashCommand
 import org.dreamexposure.discal.core.business.StaticMessageService
-import org.dreamexposure.discal.core.extensions.discord4j.followupEphemeral
 import org.dreamexposure.discal.core.extensions.discord4j.getCalendar
 import org.dreamexposure.discal.core.extensions.discord4j.hasElevatedPermissions
 import org.dreamexposure.discal.core.`object`.GuildSettings
@@ -45,16 +44,22 @@ class DisplayCalendarCommand(
        // Validate control role
        val hasElevatedPerms = event.interaction.member.get().hasElevatedPermissions().awaitSingle()
        if (!hasElevatedPerms)
-            return event.followupEphemeral(getCommonMsg("error.perms.elevated", settings)).awaitSingle()
+            return event.createFollowup(getCommonMsg("error.perms.elevated", settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()

        // Validate calendar exists
        val calendar = event.interaction.guild.flatMap { it.getCalendar(calendarNumber) }.awaitSingleOrNull()
        if (calendar == null)
-            return event.followupEphemeral(getCommonMsg("error.notFound.calendar", settings)).awaitSingle()
+            return event.createFollowup(getCommonMsg("error.notFound.calendar", settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()

        // Create and respond
        staticMessageService.createStaticMessage(settings.guildID, event.interaction.channelId, calendarNumber, hour)

-        return event.followupEphemeral(getCommonMsg("success.generic", settings)).awaitSingle()
+        return event.createFollowup(getCommonMsg("success.generic", settings))
+            .withEphemeral(ephemeral)
+            .awaitSingle()
    }
 }
@@ -5,7 +5,6 @@ import discord4j.core.`object`.entity.Message
 import kotlinx.coroutines.reactor.awaitSingle
 import org.dreamexposure.discal.client.commands.SlashCommand
 import org.dreamexposure.discal.core.config.Config
-import org.dreamexposure.discal.core.extensions.discord4j.followupEphemeral
 import org.dreamexposure.discal.core.`object`.GuildSettings
 import org.springframework.stereotype.Component

@@ -16,7 +15,7 @@ class HelpCommand : SlashCommand {
    override val ephemeral = true

    override suspend fun suspendHandle(event: ChatInputInteractionEvent, settings: GuildSettings): Message {
-        return event.followupEphemeral(
+        return event.createFollowup(
            getMessage("error.workInProgress", settings, "${Config.URL_BASE.getString()}/commands")
        ).awaitSingle()
    }
@@ -8,7 +8,6 @@ import kotlinx.coroutines.reactor.awaitSingle
 import kotlinx.coroutines.reactor.awaitSingleOrNull
 import org.dreamexposure.discal.client.commands.SlashCommand
 import org.dreamexposure.discal.core.business.EmbedService
-import org.dreamexposure.discal.core.extensions.discord4j.followup
 import org.dreamexposure.discal.core.extensions.discord4j.getCalendar
 import org.dreamexposure.discal.core.`object`.GuildSettings
 import org.dreamexposure.discal.core.utils.getCommonMsg
@@ -38,9 +37,14 @@ class LinkCalendarCommand(
            it.getCalendar(calendarNumber)
        }.awaitSingleOrNull()
        if (calendar == null) {
-            return event.followup(getCommonMsg("error.notFound.calendar", settings)).awaitSingle()
+            return event.createFollowup(getCommonMsg("error.notFound.calendar", settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()
        }

-        return event.followup(embedService.linkCalendarEmbed(calendarNumber, settings, showOverview)).awaitSingle()
+        return event.createFollowup()
+            .withEmbeds(embedService.linkCalendarEmbed(calendarNumber, settings, showOverview))
+            .withEphemeral(ephemeral)
+            .awaitSingle()
    }
 }
@@ -9,7 +9,6 @@ import kotlinx.coroutines.reactor.awaitSingleOrNull
 import org.dreamexposure.discal.client.commands.SlashCommand
 import org.dreamexposure.discal.core.business.EmbedService
 import org.dreamexposure.discal.core.business.RsvpService
-import org.dreamexposure.discal.core.extensions.discord4j.followupEphemeral
 import org.dreamexposure.discal.core.extensions.discord4j.getCalendar
 import org.dreamexposure.discal.core.extensions.discord4j.hasControlRole
 import org.dreamexposure.discal.core.extensions.discord4j.hasElevatedPermissions
@@ -60,28 +59,34 @@ class RsvpCommand(

        // Validate required conditions
        if (calendar == null)
-            return event.followupEphemeral(getCommonMsg("error.notFound.calendar", settings)).awaitSingle()
+            return event.createFollowup(getCommonMsg("error.notFound.calendar", settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()
        if (calendarEvent == null)
-            return event.followupEphemeral(getCommonMsg("error.notFound.event", settings)).awaitSingle()
+            return event.createFollowup(getCommonMsg("error.notFound.event", settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()
        if (calendarEvent.isOver())
-            return event.followupEphemeral(getCommonMsg("error.event.ended", settings)).awaitSingle()
+            return event.createFollowup(getCommonMsg("error.event.ended", settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()

        var rsvp = rsvpService.getRsvp(guild.id, eventId)

        return if (rsvp.hasRoom(userId)) {
            rsvp = rsvpService.upsertRsvp(rsvp.copyWithUserStatus(userId, goingOnTime = rsvp.goingOnTime + userId))

-            event.followupEphemeral(
-                getMessage("onTime.success", settings),
-                embedService.rsvpListEmbed(calendarEvent, rsvp, settings)
-            ).awaitSingle()
+            event.createFollowup(getMessage("onTime.success", settings))
+                .withEmbeds(embedService.rsvpListEmbed(calendarEvent, rsvp, settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()
        } else {
            rsvp = rsvpService.upsertRsvp(rsvp.copyWithUserStatus(userId, waitlist = rsvp.waitlist + userId))

-            event.followupEphemeral(
-                getMessage("onTime.failure.limit", settings),
-                embedService.rsvpListEmbed(calendarEvent, rsvp, settings)
-            ).awaitSingle()
+            event.createFollowup(getMessage("onTime.failure.limit", settings))
+                .withEmbeds(embedService.rsvpListEmbed(calendarEvent, rsvp, settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()
        }
    }

@@ -103,28 +108,34 @@ class RsvpCommand(

        // Validate required conditions
        if (calendar == null)
-            return event.followupEphemeral(getCommonMsg("error.notFound.calendar", settings)).awaitSingle()
+            return event.createFollowup(getCommonMsg("error.notFound.calendar", settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()
        if (calendarEvent == null)
-            return event.followupEphemeral(getCommonMsg("error.notFound.event", settings)).awaitSingle()
+            return event.createFollowup(getCommonMsg("error.notFound.event", settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()
        if (calendarEvent.isOver())
-            return event.followupEphemeral(getCommonMsg("error.event.ended", settings)).awaitSingle()
+            return event.createFollowup(getCommonMsg("error.event.ended", settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()

        var rsvp = rsvpService.getRsvp(guild.id, eventId)

        return if (rsvp.hasRoom(userId)) {
            rsvp = rsvpService.upsertRsvp(rsvp.copyWithUserStatus(userId, goingLate = rsvp.goingLate + userId))

-            event.followupEphemeral(
-                getMessage("late.success", settings),
-                embedService.rsvpListEmbed(calendarEvent, rsvp, settings)
-            ).awaitSingle()
+            event.createFollowup(getMessage("late.success", settings))
+                .withEmbeds(embedService.rsvpListEmbed(calendarEvent, rsvp, settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()
        } else {
            rsvp = rsvpService.upsertRsvp(rsvp.copy(waitlist = rsvp.waitlist + userId))

-            event.followupEphemeral(
-                getMessage("late.failure.limit", settings),
-                embedService.rsvpListEmbed(calendarEvent, rsvp, settings)
-            ).awaitSingle()
+            event.createFollowup(getMessage("late.failure.limit", settings))
+                .withEmbeds(embedService.rsvpListEmbed(calendarEvent, rsvp, settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()
        }
    }

@@ -146,20 +157,26 @@ class RsvpCommand(

        // Validate required conditions
        if (calendar == null)
-            return event.followupEphemeral(getCommonMsg("error.notFound.calendar", settings)).awaitSingle()
+            return event.createFollowup(getCommonMsg("error.notFound.calendar", settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()
        if (calendarEvent == null)
-            return event.followupEphemeral(getCommonMsg("error.notFound.event", settings)).awaitSingle()
+            return event.createFollowup(getCommonMsg("error.notFound.event", settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()
        if (calendarEvent.isOver())
-            return event.followupEphemeral(getCommonMsg("error.event.ended", settings)).awaitSingle()
+            return event.createFollowup(getCommonMsg("error.event.ended", settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()

        var rsvp = rsvpService.getRsvp(guild.id, eventId)

        rsvp = rsvpService.upsertRsvp(rsvp.copyWithUserStatus(userId, undecided = rsvp.undecided + userId))

-        return event.followupEphemeral(
-            getMessage("unsure.success", settings),
-            embedService.rsvpListEmbed(calendarEvent, rsvp, settings)
-        ).awaitSingle()
+        return event.createFollowup(getMessage("unsure.success", settings))
+            .withEmbeds(embedService.rsvpListEmbed(calendarEvent, rsvp, settings))
+            .withEphemeral(ephemeral)
+            .awaitSingle()
    }

    private suspend fun notGoing(event: ChatInputInteractionEvent, settings: GuildSettings): Message {
@@ -180,20 +197,26 @@ class RsvpCommand(

        // Validate required conditions
        if (calendar == null)
-            return event.followupEphemeral(getCommonMsg("error.notFound.calendar", settings)).awaitSingle()
+            return event.createFollowup(getCommonMsg("error.notFound.calendar", settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()
        if (calendarEvent == null)
-            return event.followupEphemeral(getCommonMsg("error.notFound.event", settings)).awaitSingle()
+            return event.createFollowup(getCommonMsg("error.notFound.event", settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()
        if (calendarEvent.isOver())
-            return event.followupEphemeral(getCommonMsg("error.event.ended", settings)).awaitSingle()
+            return event.createFollowup(getCommonMsg("error.event.ended", settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()

        var rsvp = rsvpService.getRsvp(guild.id, eventId)

        rsvp = rsvpService.upsertRsvp(rsvp.copyWithUserStatus(userId, notGoing = rsvp.notGoing + userId))

-        return event.followupEphemeral(
-            getMessage("notGoing.success", settings),
-            embedService.rsvpListEmbed(calendarEvent, rsvp, settings)
-        ).awaitSingle()
+        return event.createFollowup(getMessage("notGoing.success", settings))
+            .withEmbeds(embedService.rsvpListEmbed(calendarEvent, rsvp, settings))
+            .withEphemeral(ephemeral)
+            .awaitSingle()
    }

    private suspend fun remove(event: ChatInputInteractionEvent, settings: GuildSettings): Message {
@@ -214,20 +237,26 @@ class RsvpCommand(

        // Validate required conditions
        if (calendar == null)
-            return event.followupEphemeral(getCommonMsg("error.notFound.calendar", settings)).awaitSingle()
+            return event.createFollowup(getCommonMsg("error.notFound.calendar", settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()
        if (calendarEvent == null)
-            return event.followupEphemeral(getCommonMsg("error.notFound.event", settings)).awaitSingle()
+            return event.createFollowup(getCommonMsg("error.notFound.event", settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()
        if (calendarEvent.isOver())
-            return event.followupEphemeral(getCommonMsg("error.event.ended", settings)).awaitSingle()
+            return event.createFollowup(getCommonMsg("error.event.ended", settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()

        var rsvp = rsvpService.getRsvp(guild.id, eventId)

        rsvp = rsvpService.upsertRsvp(rsvp.copyWithUserStatus(userId))

-        return event.followupEphemeral(
-            getMessage("remove.success", settings),
-            embedService.rsvpListEmbed(calendarEvent, rsvp, settings)
-        ).awaitSingle()
+        return event.createFollowup(getMessage("remove.success", settings))
+            .withEmbeds(embedService.rsvpListEmbed(calendarEvent, rsvp, settings))
+            .withEphemeral(ephemeral)
+            .awaitSingle()
    }

    private suspend fun list(event: ChatInputInteractionEvent, settings: GuildSettings): Message {
@@ -247,13 +276,20 @@ class RsvpCommand(

        // Validate required conditions
        if (calendar == null)
-            return event.followupEphemeral(getCommonMsg("error.notFound.calendar", settings)).awaitSingle()
+            return event.createFollowup(getCommonMsg("error.notFound.calendar", settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()
        if (calendarEvent == null)
-            return event.followupEphemeral(getCommonMsg("error.notFound.event", settings)).awaitSingle()
+            return event.createFollowup(getCommonMsg("error.notFound.event", settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()

        val rsvp = rsvpService.getRsvp(guild.id, eventId)

-        return event.followupEphemeral(embedService.rsvpListEmbed(calendarEvent, rsvp, settings)).awaitSingle()
+        return event.createFollowup()
+            .withEmbeds(embedService.rsvpListEmbed(calendarEvent, rsvp, settings))
+            .withEphemeral(ephemeral)
+            .awaitSingle()
    }

    private suspend fun limit(event: ChatInputInteractionEvent, settings: GuildSettings): Message {
@@ -277,7 +313,9 @@ class RsvpCommand(
        // Validate control role first to reduce work
        val hasControlRole = event.interaction.member.get().hasControlRole().awaitSingle()
        if (!hasControlRole)
-            return event.followupEphemeral(getCommonMsg("error.perms.privileged", settings)).awaitSingle()
+            return event.createFollowup(getCommonMsg("error.perms.privileged", settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()


        val guild = event.interaction.guild.awaitSingle()
@@ -286,25 +324,33 @@ class RsvpCommand(

        // Validate required conditions
        if (calendar == null)
-            return event.followupEphemeral(getCommonMsg("error.notFound.calendar", settings)).awaitSingle()
+            return event.createFollowup(getCommonMsg("error.notFound.calendar", settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()
        if (calendarEvent == null)
-            return event.followupEphemeral(getCommonMsg("error.notFound.event", settings)).awaitSingle()
+            return event.createFollowup(getCommonMsg("error.notFound.event", settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()
        if (calendarEvent.isOver())
-            return event.followupEphemeral(getCommonMsg("error.event.ended", settings)).awaitSingle()
+            return event.createFollowup(getCommonMsg("error.event.ended", settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()

        var rsvp = rsvpService.getRsvp(guild.id, eventId)
        rsvp = rsvpService.upsertRsvp(rsvp.copy(limit = limit))


-        return event.followupEphemeral(
-            getMessage("limit.success", settings, limit.toString()),
-            embedService.rsvpListEmbed(calendarEvent, rsvp, settings)
-        ).awaitSingle()
+        return event.createFollowup(getMessage("limit.success", settings, limit.toString()))
+            .withEmbeds(embedService.rsvpListEmbed(calendarEvent, rsvp, settings))
+            .withEphemeral(ephemeral)
+            .awaitSingle()
    }

    private suspend fun role(event: ChatInputInteractionEvent, settings: GuildSettings): Message {
        if (!settings.patronGuild)
-            return event.followupEphemeral(getCommonMsg("error.patronOnly", settings)).awaitSingle()
+            return event.createFollowup(getCommonMsg("error.patronOnly", settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()

        val calendarNumber = event.options[0].getOption("calendar")
            .flatMap(ApplicationCommandInteractionOption::getValue)
@@ -323,7 +369,9 @@ class RsvpCommand(
        // Validate control role first to reduce work
        val hasElevatedPerms = event.interaction.member.get().hasElevatedPermissions().awaitSingle()
        if (!hasElevatedPerms)
-            return event.followupEphemeral(getCommonMsg("error.perms.elevated", settings)).awaitSingle()
+            return event.createFollowup(getCommonMsg("error.perms.elevated", settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()

        val guild = event.interaction.guild.awaitSingle()
        val calendar = guild.getCalendar(calendarNumber).awaitSingleOrNull()
@@ -331,19 +379,28 @@ class RsvpCommand(

        // Validate required conditions
        if (calendar == null)
-            return event.followupEphemeral(getCommonMsg("error.notFound.calendar", settings)).awaitSingle()
+            return event.createFollowup(getCommonMsg("error.notFound.calendar", settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()
        if (calendarEvent == null)
-            return event.followupEphemeral(getCommonMsg("error.notFound.event", settings)).awaitSingle()
+            return event.createFollowup(getCommonMsg("error.notFound.event", settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()
        if (calendarEvent.isOver())
-            return event.followupEphemeral(getCommonMsg("error.event.ended", settings)).awaitSingle()
+            return event.createFollowup(getCommonMsg("error.event.ended", settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()


        var rsvp = rsvpService.getRsvp(guild.id, eventId)
        rsvp = rsvpService.upsertRsvp(rsvp.copy(role = if (role.isEveryone) null else role.id))

        val embed = embedService.rsvpListEmbed(calendarEvent, rsvp, settings)
+        val message = if (role.isEveryone) getMessage("role.success.remove", settings) else getMessage("role.success.set", settings, role.name)

-        return if (role.isEveryone) event.followupEphemeral(getMessage("role.success.remove", settings), embed).awaitSingle()
-        else event.followupEphemeral(getMessage("role.success.set", settings, role.name), embed).awaitSingle()
+        return event.createFollowup(message)
+            .withEmbeds(embed)
+            .withEphemeral(ephemeral)
+            .awaitSingle()
    }
 }
@@ -8,7 +8,6 @@ import kotlinx.coroutines.reactor.awaitSingle
 import kotlinx.coroutines.reactor.awaitSingleOrNull
 import org.dreamexposure.discal.client.commands.SlashCommand
 import org.dreamexposure.discal.core.business.EmbedService
-import org.dreamexposure.discal.core.extensions.discord4j.followup
 import org.dreamexposure.discal.core.extensions.discord4j.getCalendar
 import org.dreamexposure.discal.core.`object`.GuildSettings
 import org.dreamexposure.discal.core.utils.getCommonMsg
@@ -34,9 +33,14 @@ class TimeCommand(
            it.getCalendar(calendarNumber)
        }.awaitSingleOrNull()
        if (calendar == null) {
-            return event.followup(getCommonMsg("error.notFound.calendar", settings)).awaitSingle()
+            return event.createFollowup(getCommonMsg("error.notFound.calendar", settings))
+                .withEphemeral(ephemeral)
+                .awaitSingle()
        }

-        return event.followup(embedService.calendarTimeEmbed(calendar, settings)).awaitSingle()
+        return event.createFollowup()
+            .withEmbeds(embedService.calendarTimeEmbed(calendar, settings))
+            .withEphemeral(ephemeral)
+            .awaitSingle()
    }
 }
@@ -1,11 +1,12 @@
 package org.dreamexposure.discal.core.extensions.discord4j

-import discord4j.core.`object`.entity.Message
 import discord4j.core.event.domain.interaction.DeferrableInteractionEvent
+import discord4j.core.`object`.entity.Message
 import discord4j.core.spec.EmbedCreateSpec
 import discord4j.core.spec.InteractionFollowupCreateSpec
 import reactor.core.publisher.Mono

+@Deprecated("lol")
 fun DeferrableInteractionEvent.followup(embed: EmbedCreateSpec): Mono<Message> {
    val spec = InteractionFollowupCreateSpec.builder()
        .addEmbed(embed)
@@ -14,6 +15,7 @@ fun DeferrableInteractionEvent.followup(embed: EmbedCreateSpec): Mono<Message> {
    return this.createFollowup(spec)
 }

+@Deprecated("lol")
 fun DeferrableInteractionEvent.followup(message: String): Mono<Message> {
    val spec = InteractionFollowupCreateSpec.builder()
        .content(message)
@@ -22,6 +24,7 @@ fun DeferrableInteractionEvent.followup(message: String): Mono<Message> {
    return this.createFollowup(spec)
 }

+@Deprecated("lol")
 fun DeferrableInteractionEvent.followup(message: String, embed: EmbedCreateSpec): Mono<Message> {
    val spec = InteractionFollowupCreateSpec.builder()
        .content(message)
@@ -31,6 +34,7 @@ fun DeferrableInteractionEvent.followup(message: String, embed: EmbedCreateSpec)
    return this.createFollowup(spec)
 }

+@Deprecated("lol")
 fun DeferrableInteractionEvent.followupEphemeral(embed: EmbedCreateSpec): Mono<Message> {
    val spec = InteractionFollowupCreateSpec.builder()
        .addEmbed(embed)
@@ -40,6 +44,7 @@ fun DeferrableInteractionEvent.followupEphemeral(embed: EmbedCreateSpec): Mono<M
    return this.createFollowup(spec)
 }

+@Deprecated("lol")
 fun DeferrableInteractionEvent.followupEphemeral(message: String): Mono<Message> {
    val spec = InteractionFollowupCreateSpec.builder()
        .content(message)
@@ -49,6 +54,7 @@ fun DeferrableInteractionEvent.followupEphemeral(message: String): Mono<Message>
    return this.createFollowup(spec)
 }

+@Deprecated("lol")
 fun DeferrableInteractionEvent.followupEphemeral(message: String, embed: EmbedCreateSpec): Mono<Message> {
    val spec = InteractionFollowupCreateSpec.builder()
        .content(message)