Add documentation to dev.plex.admin, dev.plex.banning, dev.plex.cache, and dev.plex.command (annotations and PlexCommand.java only)

Convert Date in punishments to LocalDateTime

build.gradle

@@ -74,4 +74,8 @@ tasks {
     build {
         dependsOn(shadowJar)
     }
+
+    javadoc {
+        options.memberLevel = JavadocMemberLevel.PRIVATE
+    }
 }

src/main/java/dev/plex/admin/Admin.java

@@ -6,18 +6,46 @@ import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.Setter;
 
+/**
+ * Admin object to handle cached admins
+ */
 @Getter
 @Setter
 public class Admin
 {
+    /**
+     * Gets the unique ID of an admin (immutable)
+     */
     @Setter(AccessLevel.NONE)
     private UUID uuid;
 
+    /**
+     * Gets the rank of the admin
+     * <br>
+     * Contains a #setRank and #getRank by lombok
+     */
     private Rank rank;
 
+    /**
+     * Returns if the admin has command spy or not
+     * <br>
+     * Contains a #isCommandSpy and #setCommandSpy by lombok
+     */
     private boolean commandSpy = true;
+
+    /**
+     * Returns if the admin has staff chat toggled or not
+     * <br>
+     * Contains a #isStaffChat and #setStaffChat by lombok
+     */
     private boolean staffChat = false;
 
+    /**
+     * Creates an admin with the startig ADMIN rank
+     * @param uuid
+     * @see UUID
+     * @see Rank
+     */
     public Admin(UUID uuid)
     {
         this.uuid = uuid;

src/main/java/dev/plex/admin/AdminList.java

@@ -15,21 +15,43 @@ import java.sql.SQLException;
 import java.util.List;
 import java.util.Map;
 import java.util.UUID;
+import java.util.stream.Collectors;
+
+/**
+ * Cached storage for Admin objects
+ * @see Admin
+ */
 
 public class AdminList
 {
+    /**
+     * Key/Value storage, where the key is the unique ID of the admin
+     */
     private final Map<UUID, Admin> admins = Maps.newHashMap();
 
+    /**
+     * Adds the admin to cache
+     * @param admin The admin object
+     */
     public void addToCache(Admin admin)
     {
         admins.put(admin.getUuid(), admin);
     }
 
+    /**
+     * Removes an admin from the cache
+     * @param uuid The unique ID of the admin
+     * @see UUID
+     */
     public void removeFromCache(UUID uuid)
     {
         admins.remove(uuid);
     }
 
+    /**
+     * Gathers every admin's username (cached and databsed)
+     * @return An array list of the names of every admin
+     */
     public List<String> getAllAdmins()
     {
         List<String> admins = Lists.newArrayList();
@@ -37,13 +59,7 @@ public class AdminList
         {
             Datastore store = Plex.get().getMongoConnection().getDatastore();
             Query<PlexPlayer> query = store.find(PlexPlayer.class);
-            for (PlexPlayer player : query)
+            admins.addAll(query.stream().filter(plexPlayer -> plexPlayer.getRankFromString().isAtLeast(Rank.ADMIN)).map(PlexPlayer::getName).collect(Collectors.toList()));
-            {
-                if (player.getRankFromString().isAtLeast(Rank.ADMIN))
-                {
-                    admins.add(player.getName());
-                }
-            }
         }
         else
         {

src/main/java/dev/plex/banning/Ban.java

@@ -4,6 +4,8 @@ import dev.morphia.annotations.Entity;
 import dev.morphia.annotations.Id;
 import dev.morphia.annotations.IndexOptions;
 import dev.morphia.annotations.Indexed;
+
+import java.time.LocalDateTime;
 import java.util.Date;
 import java.util.UUID;
 import lombok.AccessLevel;
@@ -11,43 +13,90 @@ import lombok.Getter;
 import lombok.Setter;
 import org.apache.commons.lang.RandomStringUtils;
 
+/**
+ * The ban object
+ * @see BanManager
+ */
 @Getter
 @Setter
 @Entity(value = "bans", useDiscriminator = false)
 public class Ban
 {
-    public Ban()
+    /**
+     * A constructor for Morphia, can't be used
+     */
+    private Ban()
     {
     }
 
+    /**
+     * Gets the id of the ban (first 8 characters of a UUID + random 6 letters)
+     */
     @Setter(AccessLevel.NONE)
     @Id
     private String id;
 
+    /**
+     * The unique ID of the player who was banned
+     */
     @Setter(AccessLevel.NONE)
     @Indexed(options = @IndexOptions(unique = true))
     private UUID uuid;
 
+    /**
+     * The unique ID of the person who banned the player (can be null)
+     */
     @Indexed // have the banner be indexed in the future to get bans issued by a person
     private UUID banner;
 
+    /**
+     * The IP of the banned player
+     */
     private String ip;
+
+    /**
+     * The reason for the ban
+     */
     private String reason;
-    private Date endDate;
+
+    /**
+     * The end date for the ban
+     */
+    private LocalDateTime endDate;
+
+    /**
+     * Whether the ban is active or not
+     */
     private boolean active;
 
-    public Ban(UUID uuid, UUID banner, String ip, String reason, Date endDate)
+    /**
+     * Creates a ban object
+     * @param uuid The unique ID of the player being banned
+     * @param banner The unique ID of the sender banning the player
+     * @param ip The IP of the player being banned
+     * @param reason The reason for the ban
+     * @param endDate When the ban will expire
+     */
+    public Ban(UUID uuid, UUID banner, String ip, String reason, LocalDateTime endDate)
     {
-        this.uuid = uuid;
+        this(uuid.toString().substring(0, 8) + "-" + RandomStringUtils.randomAlphabetic(6),
-        this.id = uuid.toString().substring(0, 8) + "-" + RandomStringUtils.randomAlphabetic(6);
+                uuid,
-        this.banner = banner;
+                banner,
-        this.ip = ip;
+                ip,
-        this.reason = reason;
+                reason,
-        this.endDate = endDate;
+                endDate);
-        this.active = true;
     }
 
-    public Ban(String id, UUID uuid, UUID banner, String ip, String reason, Date endDate)
+    /**
+     * Creates a ban object
+     * @param id The custom ID of the ban
+     * @param uuid The unique ID of the player being banned
+     * @param banner The unique ID of the sender banning the player
+     * @param ip The IP of the player being banned
+     * @param reason The reason for the ban
+     * @param endDate When the ban will expire
+     */
+    public Ban(String id, UUID uuid, UUID banner, String ip, String reason, LocalDateTime endDate)
     {
         this.uuid = uuid;
         this.id = id;

src/main/java/dev/plex/banning/BanManager.java

@@ -6,11 +6,15 @@ import dev.morphia.query.experimental.filters.Filters;
 import dev.morphia.query.experimental.updates.UpdateOperators;
 import dev.plex.Plex;
 import dev.plex.storage.StorageType;
+
 import java.sql.Connection;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
-import java.util.Date;
+import java.time.Instant;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.ZoneOffset;
 import java.util.List;
 import java.util.UUID;
 
@@ -19,6 +23,10 @@ public class BanManager
     private final String SELECT = "SELECT * FROM `bans` WHERE uuid=?";
     private final String INSERT = "INSERT INTO `bans` (`banID`, `uuid`, `banner`, `ip`, `reason`, `enddate`, `active`) VALUES (?, ?, ?, ?, ?, ?, ?);";
 
+    /**
+     * Adds the ban to the database
+     * @param ban The ban object
+     */
     public void executeBan(Ban ban)
     {
         if (Plex.get().getStorageType() == StorageType.MONGODB)
@@ -35,7 +43,7 @@ public class BanManager
                 statement.setString(3, ban.getBanner() == null ? "" : ban.getBanner().toString());
                 statement.setString(4, ban.getIp());
                 statement.setString(5, ban.getReason());
-                statement.setLong(6, ban.getEndDate().toInstant().toEpochMilli());
+                statement.setLong(6, ban.getEndDate().toInstant(ZoneOffset.of(ZoneId.systemDefault().getId())).toEpochMilli());
                 statement.setBoolean(7, ban.isActive());
                 statement.execute();
 
@@ -47,6 +55,11 @@ public class BanManager
         }
     }
 
+    /**
+     * Checks if the unique ID has an active ban in the database
+     * @param uuid The unique ID of the player
+     * @return true if the unique ID is banned
+     */
     public boolean isBanned(UUID uuid)
     {
         if (Plex.get().getStorageType() == StorageType.MONGODB)
@@ -81,6 +94,10 @@ public class BanManager
         return false;
     }
 
+    /**
+     * Unbans a player if they have an active ban on record
+     * @param uuid The unique ID of the player
+     */
     public void unban(UUID uuid)
     {
         if (Plex.get().getStorageType() == StorageType.MONGODB)
@@ -95,9 +112,10 @@ public class BanManager
         {
             try (Connection con = Plex.get().getSqlConnection().getCon())
             {
-                PreparedStatement statement = con.prepareStatement("UPDATE `bans` SET active=? WHERE uuid=?");
+                PreparedStatement statement = con.prepareStatement("UPDATE `bans` SET active=? WHERE uuid=? AND active=?");
                 statement.setBoolean(1, false);
                 statement.setString(2, uuid.toString());
+                statement.setBoolean(3, true);
                 statement.executeUpdate();
             }
             catch (SQLException throwables)
@@ -107,6 +125,10 @@ public class BanManager
         }
     }
 
+    /**
+     * Unbans a player if they have an active ban on record
+     * @param id Custom ID of the ban
+     */
     public void unban(String id)
     {
         if (Plex.get().getStorageType() == StorageType.MONGODB)
@@ -133,6 +155,10 @@ public class BanManager
         }
     }
 
+    /**
+     * Gets a list of all the current bans active
+     * @return An arraylist of bans
+     */
     public List<Ban> getActiveBans()
     {
         List<Ban> bans = Lists.newArrayList();
@@ -158,7 +184,7 @@ public class BanManager
                         UUID banner = set.getString("banner").isEmpty() ? null : UUID.fromString(set.getString("banner"));
                         String ip = set.getString("ip");
                         String reason = set.getString("reason");
-                        Date endDate = set.getLong("enddate") != 0 ? new Date(set.getLong("enddate")) : null;
+                        LocalDateTime endDate = set.getLong("enddate") != 0 ? LocalDateTime.ofInstant(Instant.ofEpochMilli(set.getLong("enddate")), ZoneId.systemDefault()) : null;
                         Ban ban = new Ban(id, uuid, banner, ip, reason, endDate);
                         bans.add(ban);
                     }

src/main/java/dev/plex/cache/DataUtils.java

@@ -6,10 +6,16 @@ import dev.plex.storage.StorageType;
 import java.util.UUID;
 import org.bukkit.Bukkit;
 
+/**
+ * Parent cache class
+ */
 public class DataUtils
 {
-    /* PLEX PLAYER METHODS */
+    /**
-
+     * Checks if the player has been on the server before
+     * @param uuid The unique ID of the player
+     * @return true if the player is registered in the database
+     */
     public static boolean hasPlayedBefore(UUID uuid)
     {
         if (Plex.get().getStorageType() == StorageType.MONGODB)
@@ -22,6 +28,12 @@ public class DataUtils
         }
     }
 
+    /**
+     * Gets a player from cache or from the database
+     * @param uuid The unique ID of the player
+     * @return a PlexPlayer object
+     * @see PlexPlayer
+     */
     public static PlexPlayer getPlayer(UUID uuid)
     {
         if (PlayerCache.getPlexPlayerMap().containsKey(uuid))
@@ -39,11 +51,22 @@ public class DataUtils
         }
     }
 
+    /**
+     * Gets a player from cache or from the database
+     * @param name Username of the player
+     * @return a PlexPlayer object
+     * @see PlexPlayer
+     */
     public static PlexPlayer getPlayer(String name)
     {
         return getPlayer(Bukkit.getPlayer(name).getUniqueId());
     }
 
+    /**
+     * Updates a player's information in the database
+     * @param plexPlayer The PlexPlayer to update
+     * @see PlexPlayer
+     */
     public static void update(PlexPlayer plexPlayer)
     {
         if (Plex.get().getStorageType() == StorageType.MONGODB)
@@ -56,6 +79,11 @@ public class DataUtils
         }
     }
 
+    /**
+     * Inserts a player's information in the database
+     * @param plexPlayer The PlexPlayer to insert
+     * @see PlexPlayer
+     */
     public static void insert(PlexPlayer plexPlayer)
     {
         if (Plex.get().getStorageType() == StorageType.MONGODB)

src/main/java/dev/plex/cache/MongoPlayerData.java

@@ -9,15 +9,29 @@ import dev.plex.Plex;
 import dev.plex.player.PlexPlayer;
 import java.util.UUID;
 
+/**
+ * Mongo fetching utilities for players
+ */
 public class MongoPlayerData
 {
+    /**
+     * The datastore object / database
+     */
     private final Datastore datastore;
 
+    /**
+     * Creates an instance of the player data
+     */
     public MongoPlayerData()
     {
         this.datastore = Plex.get().getMongoConnection().getDatastore();
     }
 
+    /**
+     * Checks whether the player exists in mongo's database
+     * @param uuid The unique ID of the player
+     * @return true if the player was found
+     */
     public boolean exists(UUID uuid)
     {
         Query<PlexPlayer> query = datastore.find(PlexPlayer.class)
@@ -26,6 +40,12 @@ public class MongoPlayerData
         return query.first() != null;
     }
 
+    /**
+     * Gets the player from cache or from mongo's database
+     * @param uuid The unique ID of the player
+     * @return a PlexPlayer object
+     * @see PlexPlayer
+     */
     public PlexPlayer getByUUID(UUID uuid)
     {
         if (PlayerCache.getPlexPlayerMap().containsKey(uuid))
@@ -37,6 +57,11 @@ public class MongoPlayerData
         return query2.first();
     }
 
+    /**
+     * Updates a player's information in the mongo database
+     * @param player The PlexPlayer object
+     * @see PlexPlayer
+     */
     public void update(PlexPlayer player)
     {
         Query<PlexPlayer> filter = datastore.find(PlexPlayer.class)
@@ -56,6 +81,11 @@ public class MongoPlayerData
     }
 
 
+    /**
+     * Saves the player's information in the database
+     * @param plexPlayer The PlexPlayer object
+     * @see PlexPlayer
+     */
     public void save(PlexPlayer plexPlayer)
     {
         datastore.save(plexPlayer);

src/main/java/dev/plex/cache/PlayerCache.java

@@ -6,9 +6,20 @@ import dev.plex.player.PunishedPlayer;
 import java.util.Map;
 import java.util.UUID;
 
+/**
+ * Cache storage
+ */
+
 public class PlayerCache
 {
+    /**
+     * A key/value pair where the key is the unique ID of the Plex Player
+     */
     private static final Map<UUID, PlexPlayer> plexPlayerMap = Maps.newHashMap();
+
+    /**
+     * A key/value pair where the key is the unique ID of the Punished Player
+     */
     private static final Map<UUID, PunishedPlayer> punishedPlayerMap = Maps.newHashMap();
 
     public static Map<UUID, PunishedPlayer> getPunishedPlayerMap()

src/main/java/dev/plex/cache/SQLPlayerData.java

@@ -11,12 +11,20 @@ import java.sql.SQLException;
 import java.util.List;
 import java.util.UUID;
 
+/**
+ * SQL fetching utilities for players
+ */
 public class SQLPlayerData
 {
     private final String SELECT = "SELECT * FROM `players` WHERE uuid=?";
     private final String UPDATE = "UPDATE `players` SET name=?, login_msg=?, prefix=?, rank=?, ips=?, coins=?, vanished=? WHERE uuid=?";
     private final String INSERT = "INSERT INTO `players` (`uuid`, `name`, `login_msg`, `prefix`, `rank`, `ips`, `coins`, `vanished`) VALUES (?, ?, ?, ?, ?, ?, ?, ?);";
 
+    /**
+     * Checks if a player exists in the SQL database
+     * @param uuid The unique ID of the player
+     * @return true if the player was found in the database
+     */
     public boolean exists(UUID uuid)
     {
         try (Connection con = Plex.get().getSqlConnection().getCon())
@@ -33,6 +41,12 @@ public class SQLPlayerData
         return false;
     }
 
+    /**
+     * Gets the player from cache or from the SQL database
+     * @param uuid The unique ID of the player
+     * @return a PlexPlayer object
+     * @see PlexPlayer
+     */
     public PlexPlayer getByUUID(UUID uuid)
     {
         if (PlayerCache.getPlexPlayerMap().containsKey(uuid))
@@ -74,6 +88,11 @@ public class SQLPlayerData
         return null;
     }
 
+    /**
+     * Updates a player's information in the SQL database
+     * @param player The PlexPlayer object
+     * @see PlexPlayer
+     */
     public void update(PlexPlayer player)
     {
         try (Connection con = Plex.get().getSqlConnection().getCon())
@@ -95,6 +114,11 @@ public class SQLPlayerData
         }
     }
 
+    /**
+     * Inserts the player's information in the database
+     * @param player The PlexPlayer object
+     * @see PlexPlayer
+     */
     public void insert(PlexPlayer player)
     {
         try (Connection con = Plex.get().getSqlConnection().getCon())

src/main/java/dev/plex/command/PlexCommand.java

@@ -26,16 +26,39 @@ import org.jetbrains.annotations.Nullable;
 import java.util.Arrays;
 import java.util.UUID;
 
+/**
+ * Superclass for all commands
+ */
 public abstract class PlexCommand extends Command implements PluginIdentifiableCommand
 {
+    /**
+     * Returns the instance of the plugin
+     */
     protected static Plex plugin = Plex.get();
 
+    /**
+     * The parameters for the command
+     */
     private final CommandParameters params;
+
+    /**
+     * The permissions for the command
+     */
     private final CommandPermissions perms;
 
+    /**
+     * Minimum required rank fetched from the permissions
+     */
     private final Rank level;
+
+    /**
+     * Required command source fetched from the permissions
+     */
     private final RequiredCommandSource commandSource;
 
+    /**
+     * Creates an instance of the command
+     */
     public PlexCommand()
     {
         super("");
@@ -56,9 +79,19 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
         getMap().register("plex", this);
     }
 
+    /**
+     * Executes the command
+     * @param sender The sender of the command
+     * @param playerSender The player who executed the command (null if command source is console or if command source is any but console executed)
+     * @param args A Kyori Component to send to the sender (can be null)
+     * @return
+     */
     protected abstract Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, @NotNull String[] args);
 
 
+    /**
+     * @hidden
+     */
     @Override
     public boolean execute(@NotNull CommandSender sender, @NotNull String label, String[] args)
     {
@@ -158,6 +191,11 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
     }
 
 
+    /**
+     * Checks if the string given is a command string
+     * @param label The string to check
+     * @return true if the string is a command name or alias
+     */
     private boolean matches(String label)
     {
         if (params.aliases().split(",").length > 0)
@@ -176,31 +214,63 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
         return false;
     }
 
+    /**
+     * Gets a PlexPlayer from Player object
+     * @param player The player object
+     * @return  PlexPlayer Object
+     * @see PlexPlayer
+     */
     protected PlexPlayer getPlexPlayer(@NotNull Player player)
     {
         return DataUtils.getPlayer(player.getUniqueId());
     }
 
+    /**
+     * Sends a message to an audience
+     * @param audience The audience to send the message to
+     * @param s The message to send
+     */
     protected void send(Audience audience, String s)
     {
         audience.sendMessage(componentFromString(s));
     }
 
+    /**
+     * Sends a message to an audience
+     * @param audience The audience to send the message to
+     * @param component The component to send
+     */
     protected void send(Audience audience, Component component)
     {
         audience.sendMessage(component);
     }
 
+    /**
+     * Checks whether a sender has enough permissions or is high enough a rank
+     * @param sender A command sender
+     * @param rank The rank to check (if the server is using ranks)
+     * @param permission The permission to check (if the server is using permissions)
+     * @return true if the sender has enough permissions
+     * @see Rank
+     */
     protected boolean checkRank(CommandSender sender, Rank rank, String permission)
     {
         if (!isConsole(sender))
         {
-            checkRank((Player) sender, rank, permission);
+            return checkRank((Player) sender, rank, permission);
-            return true;
+//            return true;
         }
         return true;
     }
 
+    /**
+     * Checks whether a player has enough permissions or is high enough a rank
+     * @param player The player object
+     * @param rank The rank to check (if the server is using ranks)
+     * @param permission The permission to check (if the server is using permissions)
+     * @return true if the sender has enough permissions
+     * @see Rank
+     */
     protected boolean checkRank(Player player, Rank rank, String permission)
     {
         PlexPlayer plexPlayer = getPlexPlayer(player);
@@ -220,11 +290,22 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
         return true;
     }
 
+    /**
+     * Checks if a player is an admin
+     * @param plexPlayer The PlexPlayer object
+     * @return true if the player is an admin
+     * @see PlexPlayer
+     */
     protected boolean isAdmin(PlexPlayer plexPlayer)
     {
         return Plex.get().getRankManager().isAdmin(plexPlayer);
     }
 
+    /**
+     * Checks if a sender is an admin
+     * @param sender A command sender
+     * @return true if the sender is an admin or if console
+     */
     protected boolean isAdmin(CommandSender sender)
     {
         if (!(sender instanceof Player player))
@@ -235,12 +316,22 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
         return plugin.getRankManager().isAdmin(plexPlayer);
     }
 
+    /**
+     * Checks if a username is an admin
+     * @param name The username
+     * @return true if the username is an admin
+     */
     protected boolean isAdmin(String name)
     {
         PlexPlayer plexPlayer = DataUtils.getPlayer(name);
         return plugin.getRankManager().isAdmin(plexPlayer);
     }
 
+    /**
+     * Checks if a sender is a senior admin
+     * @param sender A command sender
+     * @return true if the sender is a senior admin or if console
+     */
     protected boolean isSeniorAdmin(CommandSender sender)
     {
         if (!(sender instanceof Player player))
@@ -251,6 +342,12 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
         return plugin.getRankManager().isSeniorAdmin(plexPlayer);
     }
 
+    /**
+     * Gets the UUID of the sender
+     * @param sender A command sender
+     * @return A unique ID or null if the sender is console
+     * @see UUID
+     */
     protected UUID getUUID(CommandSender sender)
     {
         if (!(sender instanceof Player player))
@@ -260,23 +357,43 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
         return player.getUniqueId();
     }
 
+    /**
+     * The plugin
+     * @return The instance of the plugin
+     * @see Plex
+     */
     @Override
-    public @NotNull Plugin getPlugin()
+    public @NotNull Plex getPlugin()
     {
         return plugin;
     }
 
-
+    /**
+     * Checks whether a sender is console
+     * @param sender A command sender
+     * @return true if the sender is console
+     */
     protected boolean isConsole(CommandSender sender)
     {
         return !(sender instanceof Player);
     }
 
+    /**
+     * Converts a message entry from the "messages.yml" to a component
+     * @param s The message entry
+     * @param objects Any objects to replace in order
+     * @return A kyori component
+     */
     protected Component tl(String s, Object... objects)
     {
         return componentFromString(PlexUtils.tl(s, objects));
     }
 
+    /**
+     * Converts usage to a component
+     * @param s The usage to convert
+     * @return A kyori component stating the usage
+     */
     protected Component usage(String s)
     {
         return componentFromString(ChatColor.YELLOW + "Correct Usage: " + ChatColor.GRAY + s);
@@ -323,6 +440,11 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
         return world;
     }
 
+    /**
+     * Converts a string to a legacy kyori component
+     * @param s The string to convert
+     * @return A kyori component
+     */
     protected Component componentFromString(String s)
     {
         return LegacyComponentSerializer.legacyAmpersand().deserialize(s);

src/main/java/dev/plex/command/annotation/CommandParameters.java

@@ -3,14 +3,33 @@ package dev.plex.command.annotation;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 
+/**
+ * Storage for a command's parameters
+ */
 @Retention(RetentionPolicy.RUNTIME)
 public @interface CommandParameters
 {
+    /**
+     * The name
+     * @return Name of the command
+     */
     String name();
 
+    /**
+     * The description
+     * @return Description of the command
+     */
     String description() default "";
 
+    /**
+     * The usage (optional)
+     * @return The usage of the command
+     */
     String usage() default "/<command>";
 
+    /**
+     * The aliases (optional)
+     * @return The aliases of the command
+     */
     String aliases() default "";
 }

src/main/java/dev/plex/command/annotation/CommandPermissions.java

@@ -5,12 +5,29 @@ import dev.plex.rank.enums.Rank;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 
+/**
+ * Storage for the command's permissions
+ */
 @Retention(RetentionPolicy.RUNTIME)
 public @interface CommandPermissions
 {
+    /**
+     * Minimum rank required
+     * @return Minimum rank required for the command
+     * @see Rank
+     */
     Rank level() default Rank.IMPOSTOR;
 
+    /**
+     * Required command source
+     * @return The required command source of the command
+     * @see RequiredCommandSource
+     */
     RequiredCommandSource source() default RequiredCommandSource.ANY;
 
+    /**
+     * The permission
+     * @return Permission of the command
+     */
     String permission() default ""; // No idea what to put here
 }

src/main/java/dev/plex/command/impl/BanCMD.java

@@ -15,6 +15,8 @@ import dev.plex.punishment.PunishmentType;
 import dev.plex.rank.enums.Rank;
 import dev.plex.util.PlexLog;
 import dev.plex.util.PlexUtils;
+
+import java.time.LocalDateTime;
 import java.util.Date;
 import java.util.List;
 import java.util.UUID;
@@ -75,8 +77,8 @@ public class BanCMD extends PlexCommand
             punishment.setReason("No reason provided.");
         }
         punishment.setPunishedUsername(plexPlayer.getName());
-        Date date = new Date();
+        LocalDateTime date = LocalDateTime.now();
-        punishment.setEndDate(DateUtils.addDays(date, 1));
+        punishment.setEndDate(date.plusDays(1));
         punishment.setCustomTime(false);
         plugin.getPunishmentManager().doPunishment(punishedPlayer, punishment);
         PlexUtils.broadcast(tl("banningPlayer", sender.getName(), plexPlayer.getName()));

src/main/java/dev/plex/command/impl/FreezeCMD.java

@@ -11,6 +11,8 @@ import dev.plex.punishment.Punishment;
 import dev.plex.punishment.PunishmentType;
 import dev.plex.rank.enums.Rank;
 import dev.plex.util.PlexUtils;
+
+import java.time.LocalDateTime;
 import java.util.Date;
 import java.util.List;
 import java.util.UUID;
@@ -36,8 +38,8 @@ public class FreezeCMD extends PlexCommand
         PunishedPlayer punishedPlayer = PlayerCache.getPunishedPlayer(player.getUniqueId());
         Punishment punishment = new Punishment(UUID.fromString(punishedPlayer.getUuid()), getUUID(sender));
         punishment.setCustomTime(false);
-        Date date = new Date();
+        LocalDateTime date = LocalDateTime.now();
-        punishment.setEndDate(DateUtils.addMinutes(date, 5));
+        punishment.setEndDate(date.plusMinutes(5));
         punishment.setType(PunishmentType.FREEZE);
         punishment.setPunishedUsername(player.getName());
         punishment.setReason("");

src/main/java/dev/plex/punishment/Punishment.java

@@ -2,6 +2,8 @@ package dev.plex.punishment;
 
 import com.google.common.collect.Lists;
 import com.google.gson.Gson;
+
+import java.time.LocalDateTime;
 import java.util.Date;
 import java.util.List;
 import java.util.UUID;
@@ -22,7 +24,7 @@ public class Punishment
     private PunishmentType type;
     private String reason;
     private boolean customTime;
-    private Date endDate;
+    private LocalDateTime endDate;
 
     public Punishment(UUID punished, UUID punisher)
     {

src/main/java/dev/plex/punishment/PunishmentManager.java

@@ -13,6 +13,10 @@ import java.io.FileInputStream;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.ZoneOffset;
+import java.time.temporal.ChronoUnit;
 import java.util.Date;
 import java.util.List;
 import java.util.Map;
@@ -101,9 +105,9 @@ public class PunishmentManager extends PlexBase
         else if (punishment.getType() == PunishmentType.FREEZE)
         {
             player.setFrozen(true);
-            Date now = new Date();
+            LocalDateTime now = LocalDateTime.now();
-            Date then = punishment.getEndDate();
+            LocalDateTime then = punishment.getEndDate();
-            long seconds = TimeUnit.MILLISECONDS.toSeconds(then.getTime() - now.getTime());
+            long seconds = ChronoUnit.SECONDS.between(now, then);
             new BukkitRunnable()
             {
                 @Override
@@ -123,9 +127,9 @@ public class PunishmentManager extends PlexBase
         else if (punishment.getType() == PunishmentType.MUTE)
         {
             player.setMuted(true);
-            Date now = new Date();
+            LocalDateTime now = LocalDateTime.now();
-            Date then = punishment.getEndDate();
+            LocalDateTime then = punishment.getEndDate();
-            long seconds = TimeUnit.MILLISECONDS.toSeconds(then.getTime() - now.getTime());
+            long seconds = ChronoUnit.SECONDS.between(now, then);
             new BukkitRunnable()
             {
                 @Override

src/main/java/dev/plex/services/impl/BanService.java

@@ -3,6 +3,8 @@ package dev.plex.services.impl;
 import dev.plex.Plex;
 import dev.plex.banning.Ban;
 import dev.plex.services.AbstractService;
+
+import java.time.LocalDateTime;
 import java.util.Date;
 import org.bukkit.Bukkit;
 
@@ -18,7 +20,7 @@ public class BanService extends AbstractService
     {
         for (Ban ban : Plex.get().getBanManager().getActiveBans())
         {
-            if (new Date().after(ban.getEndDate()))
+            if (LocalDateTime.now().isAfter(ban.getEndDate()))
             {
                 Plex.get().getBanManager().unban(ban.getId());
                 Bukkit.broadcastMessage("Plex - Unbanned " + Bukkit.getOfflinePlayer(ban.getUuid()).getName());