Added Cooldown-Types

build.gradle.kts

@@ -51,6 +51,8 @@ dependencies {
     testImplementation("org.junit.jupiter:junit-jupiter-api:5.9.0")
     testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.9.0")
     testImplementation("ch.qos.logback:logback-classic:1.4.4")
+    //needed for reasons...
+    testCompileOnly("com.google.code.findbugs:jsr305:3.0.2")
 
     implementation("com.github.DV8FromTheWorld:JDA:3e37938a3a")
     compileOnly("com.google.code.findbugs:jsr305:3.0.2")

src/examples/java/xyz/dynxsty/examples/commands/PollCommand.java

@@ -6,6 +6,7 @@
 import net.dv8tion.jda.api.interactions.commands.build.Commands;
 import net.dv8tion.jda.api.interactions.components.buttons.Button;
 import org.jetbrains.annotations.NotNull;
+import xyz.dynxsty.dih4jda.interactions.commands.application.CooldownType;
 import xyz.dynxsty.dih4jda.interactions.commands.application.SlashCommand;
 import xyz.dynxsty.dih4jda.interactions.components.ButtonHandler;
 import xyz.dynxsty.dih4jda.util.ComponentIdBuilder;
@@ -20,7 +21,7 @@ public class PollCommand extends SlashCommand implements ButtonHandler {
     public PollCommand() {
         setCommandData(Commands.slash("poll", "Creates a poll with 2 options."));
         setRequiredPermissions(Permission.MESSAGE_MANAGE);
-        setCommandCooldown(Duration.of(1, ChronoUnit.MINUTES)); // Add cooldown to prevent spam by users
+        setCommandCooldown(Duration.of(1, ChronoUnit.MINUTES), CooldownType.USER_GLOBAL); // Add cooldown to prevent spam by users
     }
 
     @Override

src/examples/java/xyz/dynxsty/examples/listeners/DIH4JDAListener.java

@@ -5,6 +5,7 @@
 import xyz.dynxsty.dih4jda.events.DIH4JDAEventListener;
 
 import javax.annotation.Nonnull;
+import java.time.ZoneId;
 
 public class DIH4JDAListener implements DIH4JDAEventListener {
 
@@ -18,8 +19,8 @@ public void onCommandException(@Nonnull CommandExceptionEvent event) {
 
     @Override
     public void onCommandCooldown(@Nonnull CommandCooldownEvent event) {
-        event.getInteraction().getMessageChannel().sendMessageFormat("Seems like you have to wait before you use the " +
-                "command again.\n You can try again in: <t:%s:R>", event.getCooldown().getNextUse().toEpochMilli()).queue();
+        event.getInteraction().replyFormat("You are on cooldown. Next use <t:%s:R>",
+                event.getCooldown().getNextUse().atZone(ZoneId.systemDefault()).toEpochSecond()).queue();
     }
 
     // add more events if you need to

src/main/java/xyz/dynxsty/dih4jda/InteractionHandler.java

@@ -37,6 +37,7 @@
 import xyz.dynxsty.dih4jda.interactions.commands.RestrictedCommand;
 import xyz.dynxsty.dih4jda.interactions.commands.application.BaseApplicationCommand;
 import xyz.dynxsty.dih4jda.interactions.commands.application.ContextCommand;
+import xyz.dynxsty.dih4jda.interactions.commands.application.CooldownType;
 import xyz.dynxsty.dih4jda.interactions.commands.application.RegistrationType;
 import xyz.dynxsty.dih4jda.interactions.commands.application.SlashCommand;
 import xyz.dynxsty.dih4jda.interactions.components.ButtonHandler;
@@ -591,12 +592,20 @@ private boolean passesRequirements(@Nonnull CommandInteraction interaction, @Non
 			}
 		}
 		// check if the command has enabled some sort of cooldown
-		if (command.getCommandCooldown() != Duration.ZERO) {
-			if (command.hasCooldown(userId)) {
-				DIH4JDAEvent.fire(new CommandCooldownEvent(dih4jda, interaction, command.retrieveCooldown(userId)));
+		Pair<Duration, CooldownType> cooldownPair = command.getCommandCooldown();
+		if (cooldownPair.getFirst() != Duration.ZERO) {
+			long guildId = interaction.getGuild().getIdLong();
+			RestrictedCommand.Cooldown cooldown = command.retrieveCooldown(userId, guildId);
+			if (command.hasCooldown(userId, guildId)) {
+				DIH4JDAEvent.fire(new CommandCooldownEvent(dih4jda, interaction, cooldown));
 				return false;
 			} else {
-				command.applyCooldown(userId, Instant.now().plus(command.getCommandCooldown()));
+				Instant nextUse = Instant.now().plus(cooldownPair.getFirst());
+				switch (cooldownPair.getSecond()) {
+					case USER_GLOBAL: command.applyCooldown(interaction.getUser(), nextUse); break;
+					case USER_GUILD: command.applyCooldown(interaction.getUser(), interaction.getGuild(), nextUse); break;
+					case GUILD: command.applyCooldown(interaction.getGuild(), nextUse); break;
+				}
 			}
 		}
 		return true;

src/main/java/xyz/dynxsty/dih4jda/events/CommandCooldownEvent.java

@@ -3,17 +3,18 @@
 import net.dv8tion.jda.api.interactions.commands.CommandInteraction;
 import xyz.dynxsty.dih4jda.DIH4JDA;
 import xyz.dynxsty.dih4jda.interactions.commands.RestrictedCommand;
+import xyz.dynxsty.dih4jda.interactions.commands.application.CooldownType;
 
 import javax.annotation.Nonnull;
 import java.time.Duration;
 
 /**
  * An event that gets fired when the user, which invoked the command, is not yet able to use this command due to
- * a specified {@link RestrictedCommand#setCommandCooldown(Duration) Command Cooldown}
+ * a specified {@link RestrictedCommand#setCommandCooldown(Duration, CooldownType)}  Command Cooldown}
  *
  * <b>Command Cooldowns DO NOT persist between sessions!</b>
  *
- * @see RestrictedCommand#setCommandCooldown(Duration)
+ * @see RestrictedCommand#setCommandCooldown(Duration, CooldownType)
  */
 public class CommandCooldownEvent extends DIH4JDAEvent<CommandInteraction> {
 

src/main/java/xyz/dynxsty/dih4jda/events/DIH4JDAEventListener.java

@@ -7,6 +7,7 @@
 import xyz.dynxsty.dih4jda.interactions.AutoCompletable;
 import xyz.dynxsty.dih4jda.interactions.commands.RestrictedCommand;
 import xyz.dynxsty.dih4jda.interactions.commands.application.ContextCommand;
+import xyz.dynxsty.dih4jda.interactions.commands.application.CooldownType;
 import xyz.dynxsty.dih4jda.interactions.commands.application.SlashCommand;
 
 import javax.annotation.Nonnull;
@@ -84,12 +85,12 @@ default void onInvalidGuild(@Nonnull InvalidGuildEvent event) {}
 
 	/**
 	 * An event that gets fired when the user, which invoked the command, is not yet able to use this command due to
-	 * a specified {@link RestrictedCommand#setCommandCooldown(Duration) Command Cooldown}<br>
+	 * a specified {@link RestrictedCommand#setCommandCooldown(Duration, CooldownType) Command Cooldown}<br>
 	 *
 	 * <b>Command Cooldowns DO NOT persist between sessions!</b><br>
 	 *
 	 * @param event The {@link CommandCooldownEvent} that was fired.
-	 * @see RestrictedCommand#setCommandCooldown(Duration)
+	 * @see RestrictedCommand#setCommandCooldown(Duration, CooldownType)
 	 */
 	default void onCommandCooldown(@Nonnull CommandCooldownEvent event) {}
 }

src/main/java/xyz/dynxsty/dih4jda/interactions/commands/RestrictedCommand.java

@@ -2,6 +2,9 @@
 
 import net.dv8tion.jda.api.Permission;
 import net.dv8tion.jda.api.entities.Guild;
+import net.dv8tion.jda.api.entities.User;
+import xyz.dynxsty.dih4jda.interactions.commands.application.CooldownType;
+import xyz.dynxsty.dih4jda.util.Pair;
 
 import javax.annotation.Nonnull;
 import java.time.Duration;
@@ -15,13 +18,14 @@
  * @since v1.6
  */
 public abstract class RestrictedCommand {
-	private final Map<Long, Cooldown> COOLDOWN_CACHE = new HashMap<>();
+	private final Map<Pair<Long, Long>, Cooldown> COOLDOWN_CACHE = new HashMap<>();
 
 	private Long[] requiredGuilds = new Long[]{};
 	private Permission[] requiredPermissions = new Permission[]{};
 	private Long[] requiredUsers = new Long[]{};
 	private Long[] requiredRoles = new Long[]{};
 	private Duration commandCooldown = Duration.ZERO;
+	private CooldownType cooldownType = CooldownType.USER_GLOBAL;
 
 	/**
 	 * Creates a default instance.
@@ -113,32 +117,75 @@ public final void setRequiredRoles(@Nonnull Long... roles) {
 	 * <b>Command Cooldowns DO NOT persist between sessions!</b><br>
 	 *
 	 * @param commandCooldown The {@link Duration} the user has to wait between command executions.
+	 * @param type The {@link CooldownType} you want to use.
 	 */
-	public void setCommandCooldown(@Nonnull Duration commandCooldown) {
+	public void setCommandCooldown(@Nonnull Duration commandCooldown, @Nonnull CooldownType type) {
 		this.commandCooldown = commandCooldown;
+		this.cooldownType = type;
 	}
 
 	/**
 	 * Returns the {@link Duration} the user has to wait between command executions.
 	 *
 	 * @return The {@link Duration}.
-	 * @see RestrictedCommand#setCommandCooldown(Duration)
+	 * @see RestrictedCommand#setCommandCooldown(Duration, CooldownType)
 	 */
 	@Nonnull
-	public Duration getCommandCooldown() {
-		return commandCooldown;
+	public Pair<Duration, CooldownType> getCommandCooldown() {
+		return new Pair<>(commandCooldown, cooldownType);
 	}
 
 	/**
-	 * Manually applies a cooldown for the specified user id.<br>
+	 * Manually applies a cooldown for the specified user and guild id.<br>
+	 * <b>Command Cooldowns DO NOT persist between sessions!</b><br>
+	 * <b>For internal use only!</b>
 	 *
+	 * @param userId The id of the user you want to apply the cooldown on.
+	 * @param guildId The id of the guild you want to apply the cooldown on.
+	 * @param  nextUse The time as an {@link Instant} where the user can execute the command the next time.
+	 */
+	private void applyCooldown(long userId, long guildId, @Nonnull Instant nextUse) {
+		COOLDOWN_CACHE.put(new Pair<>(userId, guildId), new Cooldown(Instant.now(), nextUse));
+	}
+
+	/**
+	 * Manually applies a cooldown for the specified user.<br>
+	 * Represents the {@link CooldownType#USER_GLOBAL}.<br>
 	 * <b>Command Cooldowns DO NOT persist between sessions!</b><br>
+	 * <b>For internal use only!</b>
 	 *
-	 * @param userId The targets' user id.
-	 * @param nextUse The {@link Instant} that marks the time the command can be used again.
+	 * @param user The {@link User} you want to apply the cooldown on.
+	 * @param nextUse The time as an {@link Instant} where the user can execute the command the next time.
+	 */
+	public void applyCooldown(@Nonnull User user, @Nonnull Instant nextUse) {
+		applyCooldown(user.getIdLong(), 0, nextUse);
+	}
+
+	/**
+	 * Manually applies a cooldown for the specified user and guild.<br>
+	 * Represents the {@link CooldownType#USER_GUILD}.<br>
+	 * <b>Command Cooldowns DO NOT persist between sessions!</b><br>
+	 * <b>For internal use only!</b>
+	 *
+	 * @param user The {@link User} you want to apply the cooldown on.
+	 * @param guild The {@link Guild} you want to apply the cooldown on.
+	 * @param nextUse The time as an {@link Instant} where the user can execute the command the next time.
+	 */
+	public void applyCooldown(@Nonnull User user, @Nonnull Guild guild, @Nonnull Instant nextUse) {
+		applyCooldown(user.getIdLong(), guild.getIdLong(), nextUse);
+	}
+
+	/**
+	 * Manually applies a cooldown for the specified guild.<br>
+	 * Represents the {@link CooldownType#GUILD}.<br>
+	 * <b>Command Cooldowns DO NOT persist between sessions!</b><br>
+	 * <b>For internal use only!</b>
+	 *
+	 * @param guild The {@link Guild} you want to apply the cooldown on.
+	 * @param nextUse The time as an {@link Instant} where the user can execute the command the next time.
 	 */
-	public void applyCooldown(long userId, @Nonnull Instant nextUse) {
-		COOLDOWN_CACHE.put(userId, new Cooldown(Instant.now(), nextUse));
+	public void applyCooldown(@Nonnull Guild guild, @Nonnull Instant nextUse) {
+		applyCooldown(0, guild.getIdLong(), nextUse);
 	}
 
 	/**
@@ -147,12 +194,20 @@ public void applyCooldown(long userId, @Nonnull Instant nextUse) {
 	 * both the nextUse and the lastUse of {@link Instant#EPOCH} instead.
 	 *
 	 * @param userId The targets' user id.
+	 * @param guildId The targets' guild id.
 	 * @return The {@link Instant} that marks the time the command can be used again.
 	 */
 	@Nonnull
-	public Cooldown retrieveCooldown(long userId) {
-		Cooldown cooldown = COOLDOWN_CACHE.get(userId);
-		if (cooldown == null) return new Cooldown(Instant.EPOCH, Instant.EPOCH);
+	public Cooldown retrieveCooldown(long userId, long guildId) {
+		Cooldown cooldown = null;
+		switch (cooldownType) {
+			case USER_GLOBAL: cooldown = COOLDOWN_CACHE.get(new Pair<>(userId, 0L)); break;
+			case USER_GUILD: cooldown = COOLDOWN_CACHE.get(new Pair<>(userId, guildId)); break;
+			case GUILD: cooldown = COOLDOWN_CACHE.get(new Pair<>(0L, guildId)); break;
+		}
+		if (cooldown == null) {
+			return new Cooldown(Instant.EPOCH, Instant.EPOCH);
+		}
 		return cooldown;
 	}
 
@@ -162,18 +217,30 @@ public Cooldown retrieveCooldown(long userId) {
 	 * <b>Command Cooldowns DO NOT persist between sessions!</b><br>
 	 *
 	 * @param userId The targets' user id.
+	 * @param guildId The targets' guild id.
 	 * @return Whether the command can be executed.
 	 */
-	public boolean hasCooldown(long userId) {
-		return retrieveCooldown(userId).getNextUse().isAfter(Instant.now());
+	public boolean hasCooldown(long userId, long guildId) {
+		Cooldown cooldown;
+		cooldown = retrieveCooldown(userId, guildId);
+		boolean hasCooldown = cooldown.getNextUse().isAfter(Instant.now());
+		if (!hasCooldown) {
+			switch (cooldownType) {
+				case USER_GLOBAL: COOLDOWN_CACHE.remove(new Pair<>(userId, 0L)); break;
+				case USER_GUILD: COOLDOWN_CACHE.remove(new Pair<>(userId, guildId)); break;
+				case GUILD: COOLDOWN_CACHE.remove(new Pair<>(0L, guildId)); break;
+			}
+		}
+		return hasCooldown;
 	}
 
 	/**
 	 * Model class which represents a single command cooldown.
-	 *
-	 * <h2>Command Cooldowns DO NOT persist between sessions!</h2>
+	 * <p>
+	 * <b>Command Cooldowns DO NOT persist between sessions!</b>
 	 */
 	public static class Cooldown {
+
 		private final Instant lastUse;
 		private final Instant nextUse;
 
@@ -201,5 +268,18 @@ public Instant getNextUse() {
 		public Instant getLastUse() {
 			return lastUse;
 		}
+
+		/**
+		 * Returns a string representation of the object.
+		 *
+		 * @return The representation as a {@link String}.
+		 */
+		@Override
+		public String toString() {
+			return "Cooldown{" +
+					"lastUse=" + lastUse +
+					", nextUse=" + nextUse +
+					'}';
+		}
 	}
 }

src/main/java/xyz/dynxsty/dih4jda/interactions/commands/application/CooldownType.java

@@ -0,0 +1,23 @@
+package xyz.dynxsty.dih4jda.interactions.commands.application;
+
+/**
+ * The supported {@link xyz.dynxsty.dih4jda.interactions.commands.RestrictedCommand.Cooldown} types.<br>
+ * <b>Cooldowns does not work between different shards or DIH4JDA instances.</b>
+ */
+public enum CooldownType {
+    /**
+     * Limits the amount how often a user can execute a command.<br>
+     * <b>User / Global</b>
+     */
+    USER_GLOBAL,
+    /**
+     * Limits the amount how often a user can execute a command on a guild.<br>
+     * <b>User / Guild</b><br>
+     */
+    USER_GUILD,
+    /**
+     * Limits the amount how often everyone can execute a command on a guild.<br>
+     * <b>everyone / Guild</b>
+     */
+    GUILD
+}

src/main/java/xyz/dynxsty/dih4jda/interactions/commands/application/RegistrationType.java

@@ -3,7 +3,6 @@
 /**
  * Whether the command should be queued as a global- or as a guild command.
  * <a href="https://discord.com/developers/docs/interactions/application-commands">(Read more)</a>
- *
  */
 public enum RegistrationType {
 	/**

src/main/java/xyz/dynxsty/dih4jda/util/Pair.java

@@ -1,6 +1,7 @@
 package xyz.dynxsty.dih4jda.util;
 
 import javax.annotation.Nonnull;
+import java.util.Objects;
 
 /**
  * A Pair of two elements.
@@ -43,4 +44,45 @@ public F getFirst() {
 	public S getSecond() {
 		return second;
 	}
+
+	/**
+	 * Returns a string representation of the object.
+	 *
+	 * @return The representation as a {@link String}.
+	 */
+	@Override
+	public String toString() {
+		return "Pair{" +
+				"first=" + first +
+				", second=" + second +
+				'}';
+	}
+
+	/**
+	 * Checks if the objects are qual.
+	 *
+	 * @param o The {@link Object} you want to compare.
+	 * @return True if they contain the same values.
+	 */
+	@Override
+	public boolean equals(Object o) {
+		if (this == o) {
+			return true;
+		}
+		if (o == null || getClass() != o.getClass()) {
+			return false;
+		}
+		Pair<?, ?> pair = (Pair<?, ?>) o;
+		return Objects.equals(first, pair.first) && Objects.equals(second, pair.second);
+	}
+
+	/**
+	 * Returns a hash code value for the object. This method is supported for the benefit of hash tables such as those provided by HashMap.
+	 *
+	 * @return A hash code value for this object.
+	 */
+	@Override
+	public int hashCode() {
+		return Objects.hash(first, second);
+	}
 }