Fix custom senders on Cloud-JDA

Switches the command sender class to JDACommandSender and allows for it to be constructed with a nullable MessageReceivedEvent allowing for poeple to have backwards mappers

cloud-discord/cloud-jda/src/main/java/cloud/commandframework/jda/JDACommandListener.java

@@ -59,7 +59,8 @@ public class JDACommandListener<C> extends ListenerAdapter {
     @Override
     public final void onMessageReceived(final @NonNull MessageReceivedEvent event) {
         final Message message = event.getMessage();
-        final C sender = this.commandManager.getCommandSenderMapper().apply(event);
+        final JDACommandSender jdaCommandSender = JDACommandSender.of(event);
+        final C sender = this.commandManager.getCommandSenderMapper().apply(jdaCommandSender);
 
         if (this.commandManager.getBotId() == event.getAuthor().getIdLong()) {
             return;
@@ -126,7 +127,7 @@ public class JDACommandListener<C> extends ListenerAdapter {
     }
 
     private void sendMessage(final @NonNull MessageReceivedEvent event, final @NonNull String message) {
-        event.getChannel().sendMessage(message).queue();
+        event.getChannel().sendMessage(message).complete();
     }
 
 }

cloud-discord/cloud-jda/src/main/java/cloud/commandframework/jda/JDACommandManager.java

@@ -32,7 +32,6 @@ import cloud.commandframework.meta.SimpleCommandMeta;
 import net.dv8tion.jda.api.JDA;
 import net.dv8tion.jda.api.Permission;
 import net.dv8tion.jda.api.entities.Member;
-import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
 import org.checkerframework.checker.nullness.qual.NonNull;
 import org.checkerframework.checker.nullness.qual.Nullable;
 
@@ -51,8 +50,8 @@ public class JDACommandManager<C> extends CommandManager<C> {
 
     private final Function<@NonNull C, @NonNull String> prefixMapper;
     private final BiFunction<@NonNull C, @NonNull String, @NonNull Boolean> permissionMapper;
-    private final Function<@NonNull MessageReceivedEvent, @NonNull C> commandSenderMapper;
+    private final Function<@NonNull JDACommandSender, @NonNull C> commandSenderMapper;
-    private final Function<@NonNull C, @NonNull MessageReceivedEvent> backwardsCommandSenderMapper;
+    private final Function<@NonNull C, @NonNull JDACommandSender> backwardsCommandSenderMapper;
 
     /**
      * Construct a new JDA Command Manager
@@ -61,8 +60,8 @@ public class JDACommandManager<C> extends CommandManager<C> {
      * @param prefixMapper                 Function that maps the sender to a command prefix string
      * @param permissionMapper             Function used to check if a command sender has the permission to execute a command
      * @param commandExecutionCoordinator  Coordination provider
-     * @param commandSenderMapper          Function that maps {@link MessageReceivedEvent} to the command sender type
+     * @param commandSenderMapper          Function that maps {@link JDACommandSender} to the command sender type
-     * @param backwardsCommandSenderMapper Function that maps the command sender type to {@link MessageReceivedEvent}
+     * @param backwardsCommandSenderMapper Function that maps the command sender type to {@link Member}
      * @throws InterruptedException If the jda instance does not ready correctly
      */
     public JDACommandManager(
@@ -70,8 +69,8 @@ public class JDACommandManager<C> extends CommandManager<C> {
             final @NonNull Function<@NonNull C, @NonNull String> prefixMapper,
             final @Nullable BiFunction<@NonNull C, @NonNull String, @NonNull Boolean> permissionMapper,
             final @NonNull Function<CommandTree<C>, CommandExecutionCoordinator<C>> commandExecutionCoordinator,
-            final @NonNull Function<@NonNull MessageReceivedEvent, @NonNull C> commandSenderMapper,
+            final @NonNull Function<@NonNull JDACommandSender, @NonNull C> commandSenderMapper,
-            final @NonNull Function<@NonNull C, @NonNull MessageReceivedEvent> backwardsCommandSenderMapper
+            final @NonNull Function<@NonNull C, @NonNull JDACommandSender> backwardsCommandSenderMapper
     )
             throws InterruptedException {
         super(commandExecutionCoordinator, CommandRegistrationHandler.nullCommandRegistrationHandler());
@@ -111,7 +110,7 @@ public class JDACommandManager<C> extends CommandManager<C> {
      *
      * @return Command sender mapper
      */
-    public final @NonNull Function<@NonNull MessageReceivedEvent, @NonNull C> getCommandSenderMapper() {
+    public final @NonNull Function<@NonNull JDACommandSender, @NonNull C> getCommandSenderMapper() {
         return this.commandSenderMapper;
     }
 
@@ -120,7 +119,7 @@ public class JDACommandManager<C> extends CommandManager<C> {
      *
      * @return The backwards command sender mapper
      */
-    public final @NonNull Function<@NonNull C, @NonNull MessageReceivedEvent> getBackwardsCommandSenderMapper() {
+    public final @NonNull Function<@NonNull C, @NonNull JDACommandSender> getBackwardsCommandSenderMapper() {
         return this.backwardsCommandSenderMapper;
     }
 
@@ -143,13 +142,15 @@ public class JDACommandManager<C> extends CommandManager<C> {
             return this.permissionMapper.apply(sender, permission);
         }
 
-        final MessageReceivedEvent message = this.backwardsCommandSenderMapper.apply(sender);
+        final JDACommandSender jdaSender = this.backwardsCommandSenderMapper.apply(sender);
-        final Member member = message.getMember();
+
-        if (member == null) {
+        if (!(jdaSender instanceof JDAGuildSender)) {
-            return false;
+            return true;
         }
 
-        return member.hasPermission(Permission.valueOf(permission));
+        final JDAGuildSender guildSender = (JDAGuildSender) jdaSender;
+
+        return guildSender.getMember().hasPermission(Permission.valueOf(permission));
     }
 
     @Override

cloud-discord/cloud-jda/src/main/java/cloud/commandframework/jda/JDACommandPreprocessor.java

@@ -51,8 +51,6 @@ final class JDACommandPreprocessor<C> implements CommandPreprocessor<C> {
      */
     @Override
     public void accept(final @NonNull CommandPreprocessingContext<C> context) {
-        context.getCommandContext().store("MessageReceivedEvent", mgr.getBackwardsCommandSenderMapper().apply(
-                context.getCommandContext().getSender()));
         context.getCommandContext().store("JDA", mgr.getJDA());
     }
 

cloud-discord/cloud-jda/src/main/java/cloud/commandframework/jda/JDACommandSender.java

@@ -23,9 +23,15 @@
 //
 package cloud.commandframework.jda;
 
+import java.util.Objects;
+import java.util.Optional;
+
 import net.dv8tion.jda.api.entities.ChannelType;
+import net.dv8tion.jda.api.entities.MessageChannel;
+import net.dv8tion.jda.api.entities.User;
 import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
 import org.checkerframework.checker.nullness.qual.NonNull;
+import org.checkerframework.checker.nullness.qual.Nullable;
 
 /**
  * Wrapper for {@link MessageReceivedEvent}
@@ -33,14 +39,24 @@ import org.checkerframework.checker.nullness.qual.NonNull;
 public class JDACommandSender {
 
     private final MessageReceivedEvent event;
+    private final User user;
+    private final MessageChannel channel;
 
     /**
-     * Construct a JDA Command Sender using an event
+     * Construct a JDA Command Sender
      *
-     * @param event Message Received Event
+     * @param event   Message received event
+     * @param user    Sending user
+     * @param channel Channel sent in
      */
-    public JDACommandSender(final @NonNull MessageReceivedEvent event) {
+    protected JDACommandSender(
+            final @Nullable MessageReceivedEvent event,
+            final @NonNull User user,
+            final @NonNull MessageChannel channel
+    ) {
         this.event = event;
+        this.user = user;
+        this.channel = channel;
     }
 
     /**
@@ -51,19 +67,37 @@ public class JDACommandSender {
      */
     public static JDACommandSender of(final @NonNull MessageReceivedEvent event) {
         if (event.isFromType(ChannelType.PRIVATE)) {
-            return new JDAPrivateSender(event);
+            return new JDAPrivateSender(event, event.getAuthor(), event.getPrivateChannel());
         }
 
-        return new JDAGuildSender(event);
+        return new JDAGuildSender(event, Objects.requireNonNull(event.getMember()), event.getTextChannel());
     }
 
     /**
-     * Get the {@link MessageReceivedEvent}
+     * Get the message receive event
      *
-     * @return Message Received Event
+     * @return Optional of the message receive event
      */
-    public @NonNull MessageReceivedEvent getEvent() {
+    public final @NonNull Optional<MessageReceivedEvent> getEvent() {
-        return event;
+        return Optional.ofNullable(event);
+    }
+
+    /**
+     * Get the user the command sender represents
+     *
+     * @return User that sent the message
+     */
+    public final @NonNull User getUser() {
+        return user;
+    }
+
+    /**
+     * Get the channel the user sent the message in
+     *
+     * @return Channel that the message was sent in
+     */
+    public final @NonNull MessageChannel getChannel() {
+        return channel;
     }
 
 }

cloud-discord/cloud-jda/src/main/java/cloud/commandframework/jda/JDAGuildSender.java

@@ -23,16 +23,53 @@
 //
 package cloud.commandframework.jda;
 
+import net.dv8tion.jda.api.entities.Member;
+import net.dv8tion.jda.api.entities.TextChannel;
 import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
 import org.checkerframework.checker.nullness.qual.NonNull;
+import org.checkerframework.checker.nullness.qual.Nullable;
 
 /**
  * Guild specific JDA Command Sender
  */
 public class JDAGuildSender extends JDACommandSender {
 
-    JDAGuildSender(final @NonNull MessageReceivedEvent event) {
+    private final Member member;
-        super(event);
+    private final TextChannel channel;
+
+    /**
+     * Construct a JDA Guild Sender using an event
+     *
+     * @param event   Message received event
+     * @param member  Sending member
+     * @param channel Channel sent in
+     */
+    public JDAGuildSender(
+            final @Nullable MessageReceivedEvent event,
+            final @NonNull Member member,
+            final @NonNull TextChannel channel
+    ) {
+        super(event, member.getUser(), channel);
+        this.member = member;
+        this.channel = channel;
+    }
+
+    /**
+     * Get the member the command sender represents
+     *
+     * @return Member that sent the message
+     */
+    public @NonNull Member getMember() {
+        return member;
+    }
+
+    /**
+     * Get the channel the user sent the message in
+     *
+     * @return Channel that the message was sent in
+     */
+    public @NonNull TextChannel getTextChannel() {
+        return channel;
     }
 
 }

cloud-discord/cloud-jda/src/main/java/cloud/commandframework/jda/JDAPrivateSender.java

@@ -23,16 +23,40 @@
 //
 package cloud.commandframework.jda;
 
+import net.dv8tion.jda.api.entities.PrivateChannel;
+import net.dv8tion.jda.api.entities.User;
 import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
 import org.checkerframework.checker.nullness.qual.NonNull;
+import org.checkerframework.checker.nullness.qual.Nullable;
 
 /**
  * Private message specific JDA Command Sender
  */
 public class JDAPrivateSender extends JDACommandSender {
 
-    JDAPrivateSender(final @NonNull MessageReceivedEvent event) {
+    private final PrivateChannel channel;
-        super(event);
+
+    /**
+     * Construct a JDA Private Sender using an event
+     *
+     * @param event   Message received event
+     * @param user    Sending user
+     * @param channel Channel sent in
+     */
+    public JDAPrivateSender(
+            final @Nullable MessageReceivedEvent event, final @NonNull User user, final @NonNull PrivateChannel channel
+    ) {
+        super(event, user, channel);
+        this.channel = channel;
+    }
+
+    /**
+     * Get the channel the user sent the message in
+     *
+     * @return Channel that the message was sent in
+     */
+    public PrivateChannel getPrivateChannel() {
+        return channel;
     }
 
 }