feat: finish initial implementation of seen and configs

.idea/artifacts/GoldenAge_jar.xml

···
-<component name="ArtifactManager">
-  <artifact type="jar" name="GoldenAge:jar">
-    <output-path>$PROJECT_DIR$/out/artifacts/GoldenAge_jar</output-path>
-    <root id="archive" name="GoldenAge.jar">
-      <element id="module-output" name="GoldenAge" />
-      <element id="extracted-dir" path="$USER_HOME$/Downloads/uberbukkit-2.0.2.jar" path-in-jar="/" />
-    </root>
-  </artifact>
-</component>

.idea/artifacts/GoldenAge_jar2.xml

···
-<component name="ArtifactManager">
-  <artifact type="jar" name="GoldenAge:jar2">
-    <output-path>$USER_HOME$/Coding/b173server/plugins</output-path>
-    <root id="archive" name="GoldenAge.jar">
-      <element id="module-output" name="GoldenAge" />
-      <element id="extracted-dir" path="$MAVEN_REPOSITORY$/org/xerial/sqlite-jdbc/3.49.1.0/sqlite-jdbc-3.49.1.0.jar" path-in-jar="/" />
-      <element id="extracted-dir" path="$MAVEN_REPOSITORY$/com/github/Moresteck/uberbukkit/2.0.2-241217-1442-3a5552b/uberbukkit-2.0.2-241217-1442-3a5552b.jar" path-in-jar="/" />
-    </root>
-  </artifact>
-</component>

.idea/artifacts/GoldenAge_jar3.xml

···
-<component name="ArtifactManager">
-  <artifact type="jar" name="GoldenAge:jar3">
-    <output-path>$PROJECT_DIR$/../b173server/plugins</output-path>
-    <root id="archive" name="GoldenAge.jar">
-      <element id="module-output" name="GoldenAge" />
-      <element id="extracted-dir" path="$MAVEN_REPOSITORY$/com/github/Moresteck/uberbukkit/2.0.2-241217-1442-3a5552b/uberbukkit-2.0.2-241217-1442-3a5552b.jar" path-in-jar="/" />
-      <element id="extracted-dir" path="$MAVEN_REPOSITORY$/org/xerial/sqlite-jdbc/3.49.1.0/sqlite-jdbc-3.49.1.0.jar" path-in-jar="/" />
-    </root>
-  </artifact>
-</component>

.idea/artifacts/GoldenAge_jar5.xml

···
 <component name="ArtifactManager">
   <artifact type="jar" name="GoldenAge:jar5">
-    <output-path>$PROJECT_DIR$/out/artifacts/GoldenAge_jar5</output-path>
+    <output-path>$PROJECT_DIR$/../b173server/plugins</output-path>
     <root id="archive" name="GoldenAge.jar">
       <element id="module-output" name="GoldenAge" />
       <element id="extracted-dir" path="$MAVEN_REPOSITORY$/com/fasterxml/jackson/core/jackson-annotations/2.18.3/jackson-annotations-2.18.3.jar" path-in-jar="/" />

pom.xml

···
             <artifactId>sqlite-jdbc</artifactId>
             <version>3.49.1.0</version>
         </dependency>
-        <dependency>
-            <groupId>com.fasterxml.jackson.core</groupId>
-            <artifactId>jackson-core</artifactId>
-            <version>2.18.3</version>
-        </dependency>
-        <dependency>
-            <groupId>com.fasterxml.jackson.core</groupId>
-            <artifactId>jackson-databind</artifactId>
-            <version>2.18.3</version>
-        </dependency>
-        <dependency>
-            <groupId>com.fasterxml.jackson.dataformat</groupId>
-            <artifactId>jackson-dataformat-yaml</artifactId>
-            <version>2.18.3</version>
-        </dependency>
     </dependencies>
 </project>

src/main/java/dev/keii/goldenage/GoldenAge.java

···
 import dev.keii.goldenage.commands.SeenCommand;
 import dev.keii.goldenage.config.Config;
 import dev.keii.goldenage.config.ConfigLoader;
+import dev.keii.goldenage.config.Env;
 import dev.keii.goldenage.listeners.PlayerJoinListener;
 import dev.keii.goldenage.migration.Migrator;
 import dev.keii.goldenage.utils.DatabaseUtility;
 import dev.keii.goldenage.utils.Logger;
 import lombok.Getter;
+import lombok.SneakyThrows;
 import org.bukkit.Bukkit;
+import org.bukkit.plugin.PluginManager;
 import org.bukkit.plugin.java.JavaPlugin;
 
 import java.io.*;
···
     @Getter
     private Config config;
 
-    public void setupConfig() {
-        File configFile = new File(getDataFolder(), "plugins/GoldenAge/config.yml");
+    @SneakyThrows
+    public boolean setupConfig() {
+        File configFile = new File("plugins/GoldenAge/config.yml");
 
         try {
+            if (configFile.exists()) {
+                return true;
+            }
+
+            GoldenAge.getLogger().info("Creating config...");
+
             InputStream configInputStream = getClassLoader().getResourceAsStream("config.yml");
             FileWriter configFileWriter = new FileWriter("plugins/GoldenAge/config.yml");
 
-            if (configInputStream != null && configFile.createNewFile()) {
+            if (configInputStream != null) {
                 try (BufferedReader reader = new BufferedReader(new InputStreamReader(configInputStream, StandardCharsets.UTF_8))) {
                     StringBuilder content = new StringBuilder();
                     String line;
+                    GoldenAge.getLogger().info("Writing defaults to config...");
                     while ((line = reader.readLine()) != null) {
                         content.append(line).append(System.lineSeparator());
                     }
···
                 }
 
                 configInputStream.close();
+                GoldenAge.getLogger().info("Config created!");
             }
+            return true;
         } catch (IOException e) {
             GoldenAge.getLogger().severe("Failed to create config!");
             GoldenAge.getLogger().severe(e.getMessage());
+            GoldenAge.getLogger().severe(e.toString());
             Bukkit.getPluginManager().disablePlugin(this);
+            throw e;
+            //return false;
         }
     }
 
     @Override
     public void onEnable() {
         GoldenAge.logger = new Logger("[GoldenAge]");
+        GoldenAge.getLogger().info("Enabling GoldenAge...");
 
         if (!getDataFolder().exists()) {
             getDataFolder().mkdirs();
         }
 
-        setupConfig();
+        // Return out of onEnable if setting up config failed
+        if (!setupConfig()) {
+            return;
+        }
 
         try {
+            GoldenAge.getLogger().info("Loading config.");
             this.config = ConfigLoader.loadConfig("plugins/GoldenAge/config.yml");
         } catch (IOException e) {
             GoldenAge.getLogger().severe("Failed to read config!");
···
             return;
         }
 
-        if (config.getDatabase().isAutoMigrate()) {
-            Migrator migrator = new Migrator(this);
-            try {
-                migrator.migrate();
-            } catch (SQLException e) {
-                GoldenAge.getLogger().severe("Failed to migrate db!");
-                GoldenAge.getLogger().severe(e.getMessage());
-                Bukkit.getPluginManager().disablePlugin(this);
-                return;
-            }
-        }
-
         File databaseFile = new File("plugins/GoldenAge/database.db");
 
         this.databaseUtility = new DatabaseUtility(this, "jdbc:sqlite:" + databaseFile.getAbsolutePath());
···
             return;
         }
 
-        this.getCommand("list").setExecutor(new ListCommand());
-        this.getCommand("seen").setExecutor(new SeenCommand(this));
-        this.getCommand("db").setExecutor(new DatabaseCommand(this));
+        if (config.getDatabase().isAutoMigrate()) {
+            Migrator migrator = new Migrator(this);
+            try {
+                GoldenAge.getLogger().info("Migrating database...");
+                migrator.migrate();
+                GoldenAge.getLogger().info("Finished migrating database.");
+            } catch (SQLException e) {
+                GoldenAge.getLogger().severe("Failed to migrate db!");
+                GoldenAge.getLogger().severe(e.getMessage());
+                Bukkit.getPluginManager().disablePlugin(this);
+                return;
+            }
+        }
 
-        this.getServer().getPluginManager().registerEvents(new PlayerJoinListener(this), this);
+        if (config.getCommands().getList().isEnabled())
+            this.getCommand("list").setExecutor(new ListCommand(this));
+        if (config.getCommands().getSeen().isEnabled())
+            this.getCommand("seen").setExecutor(new SeenCommand(this));
+        if (config.getEnv().equals(Env.Development))
+            this.getCommand("db").setExecutor(new DatabaseCommand(this));
+
+        PluginManager pm = this.getServer().getPluginManager();
+        pm.registerEvents(new PlayerJoinListener(this), this);
 
         GoldenAge.getLogger().info("GoldenAge has been enabled!");
     }

src/main/java/dev/keii/goldenage/commands/DatabaseCommand.java

···
 package dev.keii.goldenage.commands;
 
 import dev.keii.goldenage.GoldenAge;
+import dev.keii.goldenage.config.Env;
 import dev.keii.goldenage.migration.Migrator;
 import dev.keii.goldenage.utils.DatabaseUtility;
 import org.bukkit.command.Command;
···
 
     @Override
     public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (sender instanceof Player) {
-            if (!((Player) sender).getAddress().toString().contains("127.0.0.1")) {
-                sender.sendMessage(((Player) sender).getAddress().toString());
-                sender.sendMessage("Unknown command. Type \"help\" for help.");
-                return true;
-            }
+        // Don't allow execution of this command if the environment isn't development
+        if(!plugin.getConfig().getEnv().equals(Env.Development)) {
+            return false;
         }
 
         if (args.length == 0) {

src/main/java/dev/keii/goldenage/commands/ListCommand.java

···
 package dev.keii.goldenage.commands;
 
+import dev.keii.goldenage.GoldenAge;
 import dev.keii.goldenage.utils.PlayerUtility;
-import org.bukkit.ChatColor;
+import dev.keii.goldenage.utils.StringSubstitutor;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-import org.bukkit.plugin.PluginDescriptionFile;
-import org.bukkit.plugin.java.JavaPlugin;
+
+import java.util.HashMap;
+import java.util.Map;
 
 @SuppressWarnings("unused")
 public class ListCommand implements CommandExecutor {
+    private GoldenAge plugin;
+
+    public ListCommand(GoldenAge plugin) {
+        this.plugin = plugin;
+    }
+
     @Override
     public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
         if (command.getName().equalsIgnoreCase("list")) {
             PlayerUtility playerUtility = new PlayerUtility();
-            sender.sendMessage(ChatColor.GREEN + playerUtility.getPlayersListString());
+            Map<String, Object> params = new HashMap<>();
+            params.put("online", playerUtility.getOnlinePlayers());
+            params.put("max", playerUtility.getMaxPlayers());
+            params.put("playerList", playerUtility.getPlayersListString());
+
+            StringSubstitutor substitutor = new StringSubstitutor(params);
+            sender.sendMessage(substitutor.replace(plugin.getConfig().getCommands().getList().getFormat()));
 
             return true;
         }

src/main/java/dev/keii/goldenage/commands/SeenCommand.java

···
 import dev.keii.goldenage.models.Login;
 import dev.keii.goldenage.models.User;
 import dev.keii.goldenage.utils.DateUtility;
+import dev.keii.goldenage.utils.StringSubstitutor;
+import org.bukkit.Bukkit;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
 
 import java.time.ZoneOffset;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
 
 @SuppressWarnings("unused")
 public class SeenCommand implements CommandExecutor {
···
     @Override
     public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
         if (args.length == 0) {
-            sender.sendMessage("No argument is specified.");
+            sender.sendMessage(plugin.getConfig().getErrors().getInsufficientArguments());
             return false;
         }
 
···
         User user = userDao.getUserByUserName(args[0]);
 
         if (user == null) {
-            sender.sendMessage("§eThis user has never been seen.");
+            sender.sendMessage(plugin.getConfig().getCommands().getSeen().getNoUser());
             return true;
         }
 
···
         Login login = loginDao.getLatestLoginByUser(user);
 
         if (login == null) {
-            sender.sendMessage("§eThis user has never been seen.");
+            sender.sendMessage(plugin.getConfig().getCommands().getSeen().getNoUser());
             return true;
         }
 
+        Map<String, Object> params = new HashMap<>();
+        params.put("player", args[0]);
+
+        if (Arrays.stream(Bukkit.getOnlinePlayers()).anyMatch((Player player) -> player.getDisplayName().equalsIgnoreCase(args[0]) ))
+        {
+            StringSubstitutor substitutor = new StringSubstitutor(params);
+            sender.sendMessage(substitutor.replace(plugin.getConfig().getCommands().getSeen().getSuccessOnline()));
+            return true;
+        }
 
         String ago = DateUtility.getHumanReadableTimeSpan(login.getCreatedAt().toEpochSecond(ZoneOffset.UTC));
-        String sb = "§eThis user was seen " +
-                ago +
-                (ago.equals("now") ? "." : " ago.");
-        sender.sendMessage(sb);
+
+        if (ago.equals("now")) {
+            StringSubstitutor substitutor = new StringSubstitutor(params);
+            sender.sendMessage(substitutor.replace(plugin.getConfig().getCommands().getSeen().getSuccessNow()));
+        } else {
+            params.put("duration", ago);
+
+            StringSubstitutor substitutor = new StringSubstitutor(params);
+            sender.sendMessage(substitutor.replace(plugin.getConfig().getCommands().getSeen().getSuccessDuration()));
+        }
 
         return true;
     }

src/main/java/dev/keii/goldenage/config/CommandsConfig.java

···
+package dev.keii.goldenage.config;
+
+import dev.keii.goldenage.config.commands.ListConfig;
+import dev.keii.goldenage.config.commands.SeenConfig;
+import lombok.Getter;
+import org.bukkit.util.config.Configuration;
+
+public class CommandsConfig {
+    private final Configuration configuration;
+    @Getter
+    private ListConfig list;
+    @Getter
+    private SeenConfig seen;
+
+    public CommandsConfig(Configuration configuration) {
+        this.configuration = configuration;
+        this.list = new ListConfig(configuration);
+        this.seen = new SeenConfig(configuration);
+    }
+
+    public boolean isAutoMigrate() {
+        return this.configuration.getBoolean("database.auto-migrate", true);
+    }
+}

src/main/java/dev/keii/goldenage/config/Config.java

···
 package dev.keii.goldenage.config;
 
+import dev.keii.goldenage.GoldenAge;
 import lombok.Getter;
 import lombok.Setter;
+import org.bukkit.util.config.Configuration;
 
 public class Config {
     @Getter
-    @Setter
     private DatabaseConfig database;
+
+    @Getter
+    private CommandsConfig commands;
+
+    @Getter
+    private ErrorsConfig errors;
+
+    private final Configuration configuration;
+
+    public Config(Configuration configuration)
+    {
+        this.configuration = configuration;
+        this.database = new DatabaseConfig(configuration);
+        this.commands = new CommandsConfig(configuration);
+        this.errors = new ErrorsConfig(configuration);
+    }
+
+    public Env getEnv()
+    {
+        String envString = configuration.getString("env", "development");
+
+        switch(envString.toLowerCase())
+        {
+            case "development": return Env.Development;
+            case "production":
+                return Env.Production;
+            // Env is defaulted to production instead of throwing so the plugin still runs
+            default:
+                GoldenAge.getLogger().warning("Invalid env in config. Accepted values are 'development' and 'production'.");
+                return Env.Production;
+        }
+    }
 }

src/main/java/dev/keii/goldenage/config/ConfigLoader.java

···
 package dev.keii.goldenage.config;
 
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.dataformat.yaml.YAMLFactory;
+import org.bukkit.util.config.Configuration;
 
 import java.io.File;
 import java.io.IOException;
 
 public class ConfigLoader {
     public static Config loadConfig(String filePath) throws IOException {
-        ObjectMapper mapper = new ObjectMapper(new YAMLFactory());
-        return mapper.readValue(new File(filePath), Config.class);
+        Configuration config = new Configuration(new File(filePath));
+        return new Config(config);
     }
 }

src/main/java/dev/keii/goldenage/config/DatabaseConfig.java

···
 
 import lombok.Getter;
 import lombok.Setter;
+import org.bukkit.util.config.Configuration;
 
 public class DatabaseConfig {
-    @Getter
-    @Setter
-    private boolean autoMigrate;
+    private final Configuration configuration;
+
+    public DatabaseConfig(Configuration configuration)
+    {
+        this.configuration = configuration;
+    }
+
+    public boolean isAutoMigrate()
+    {
+        return this.configuration.getBoolean("database.auto-migrate", true);
+    }
 }

src/main/java/dev/keii/goldenage/config/Env.java

···
+package dev.keii.goldenage.config;
+
+public enum Env {
+    Production,
+    Development
+}

src/main/java/dev/keii/goldenage/config/ErrorsConfig.java

···
+package dev.keii.goldenage.config;
+
+import org.bukkit.util.config.Configuration;
+
+public class ErrorsConfig {
+    private final Configuration configuration;
+
+    public ErrorsConfig(Configuration configuration) {
+        this.configuration = configuration;
+    }
+
+    public String getInsufficientArguments() {
+        return this.configuration.getString("errors.insufficient-arguments", "§cNot enough arguments");
+    }
+}

src/main/java/dev/keii/goldenage/config/commands/ListConfig.java

···
+package dev.keii.goldenage.config.commands;
+
+import org.bukkit.util.config.Configuration;
+
+public class ListConfig {
+    private final Configuration configuration;
+
+    public ListConfig(Configuration configuration)
+    {
+        this.configuration = configuration;
+    }
+
+    public boolean isEnabled()
+    {
+        return this.configuration.getBoolean("commands.list.enabled", true);
+    }
+
+    public String getFormat() {
+        return this.configuration.getString("commands.list.format", "§eOnline players (${online}/${max}): ${playerList}");
+    }
+}

src/main/java/dev/keii/goldenage/config/commands/SeenConfig.java

···
+package dev.keii.goldenage.config.commands;
+
+import org.bukkit.util.config.Configuration;
+
+public class SeenConfig {
+    private final Configuration configuration;
+
+    public SeenConfig(Configuration configuration) {
+        this.configuration = configuration;
+    }
+
+    public boolean isEnabled() {
+        return this.configuration.getBoolean("commands.seen.enabled", true);
+    }
+
+    public String getNoUser() {
+        return this.configuration.getString("commands.seen.no-user", "§cThis user has never been seen.");
+    }
+
+    public String getSuccessDuration() {
+        return this.configuration.getString("commands.seen.success-duration", "§e${player} was seen ${duration} ago.");
+    }
+
+    public String getSuccessNow() {
+        return this.configuration.getString("commands.seen.success-now", "§e${player} was seen now.");
+    }
+
+    public String getSuccessOnline() {
+        return this.configuration.getString("commands.seen.success-online", "§e${player} is online.");
+    }
+}

src/main/java/dev/keii/goldenage/listeners/PlayerJoinListener.java

···
 import org.bukkit.event.player.PlayerJoinEvent;
 
 import java.time.LocalDateTime;
+import java.time.ZoneOffset;
 
 public class PlayerJoinListener implements Listener {
 
···
         UserDao userDao = new UserDao(plugin.getDatabaseUtility());
         User user = userDao.getUserByUuid(event.getPlayer().getUniqueId());
         if (user == null) {
-            user = new User(event.getPlayer().getUniqueId(), LocalDateTime.now(), null);
+            user = new User(event.getPlayer().getUniqueId(), LocalDateTime.now(ZoneOffset.UTC), null);
             user = userDao.insertUser(user);
             Bukkit.getLogger().info("Created user in db for " + event.getPlayer().getDisplayName());
         }
         UserNameDao userNameDao = new UserNameDao(plugin.getDatabaseUtility());
         UserName userName = userNameDao.getUserNameByName(event.getPlayer().getDisplayName());
         if (userName == null) {
-            userName = new UserName(user, event.getPlayer().getDisplayName(), LocalDateTime.now());
+            userName = new UserName(user, event.getPlayer().getDisplayName(), LocalDateTime.now(ZoneOffset.UTC));
             userNameDao.insertUserName(userName);
         }
 
-        Login login = new Login(user, LocalDateTime.now());
+        Login login = new Login(user, LocalDateTime.now(ZoneOffset.UTC));
         LoginDao loginDao = new LoginDao(plugin.getDatabaseUtility());
         loginDao.insertLogin(login);
     }

src/main/java/dev/keii/goldenage/migration/Migrator.java

···
     public void migrate() throws SQLException {
         int newBatch = getLatestBatch() + 1;
 
-        GoldenAge.getLogger().info("Migrate");
         for (Migration migration : migrations)
         {
             migration.migrate(newBatch);
···
 
     public void rollback() throws SQLException {
         int latestBatch = getLatestBatch();
-
-        GoldenAge.getLogger().info("Rollback");
 
         Collections.reverse(migrations);
         for (Migration migration : migrations)

src/main/java/dev/keii/goldenage/utils/DateUtility.java

···
             return null;
         }
 
-        GoldenAge.getLogger().info(epochTimeSeconds.toString());
-        GoldenAge.getLogger().info(String.valueOf((long) epochTimeSeconds * 1000L));
         Instant instant = Instant.ofEpochMilli((long) epochTimeSeconds * 1000L);
 
         return instant.atZone(ZoneId.ofOffset("UTC", ZoneOffset.UTC)).toLocalDateTime();

src/main/java/dev/keii/goldenage/utils/PlayerUtility.java

···
     public String getPlayersListString()
     {
         Player[] players = Bukkit.getOnlinePlayers();
-        int onlinePlayers = players.length;
-        int maxPlayers = Bukkit.getMaxPlayers();
 
         StringBuilder playerList = new StringBuilder();
         for (Player player : players) {
···
         }
         playerList.setLength(playerList.length() - 2);
 
-        return "Online players (" + onlinePlayers + "/" + maxPlayers + "): " + playerList.toString();
+        return playerList.toString();
+    }
+
+    public int getOnlinePlayers()
+    {
+        Player[] players = Bukkit.getOnlinePlayers();
+        return players.length;
+    }
+
+    public int getMaxPlayers()
+    {
+        return Bukkit.getMaxPlayers();
     }
 }

src/main/java/dev/keii/goldenage/utils/StringSubstitutor.java

···
+package dev.keii.goldenage.utils;
+
+import java.util.Map;
+import java.util.regex.Pattern;
+
+public class StringSubstitutor {
+    private final Map<String, Object> map;
+
+    public StringSubstitutor(Map<String, Object> map) {
+        this.map = map;
+    }
+
+    public String replace(String str) {
+        String finalString  = str;
+        for (Map.Entry<String, Object> entry : map.entrySet()) {
+            finalString = finalString.replace("${" + entry.getKey() +  "}", String.valueOf(entry.getValue()));
+        }
+        return finalString;
+    }
+}

src/main/resources/config.yml

···
+env: production
 database:
-  auto-migrate: true
+  auto-migrate: true
+errors:
+  insufficient-arguments: "§cNot enough arguments"
+commands:
+  list:
+    format: "§eOnline players (${online}/${max}): ${playerList}"
+    enabled: true
+  seen:
+    no-user: "§cThis user has never been seen."
+    success-duration: "§e${player} was seen ${duration} ago."
+    success-now: "§e${player} was seen now."
+    success-online: "§e${player} is online."
+    enabled: true