Feat/file storage

PistonChat/src/main/java/net/pistonmaster/pistonchat/PistonChat.java

@@ -15,6 +15,9 @@
 import net.pistonmaster.pistonchat.commands.whisper.ReplyCommand;
 import net.pistonmaster.pistonchat.commands.whisper.WhisperCommand;
 import net.pistonmaster.pistonchat.events.ChatEvent;
+import net.pistonmaster.pistonchat.storage.PCStorage;
+import net.pistonmaster.pistonchat.storage.file.FileStorage;
+import net.pistonmaster.pistonchat.storage.mysql.MySQLStorage;
 import net.pistonmaster.pistonchat.tools.*;
 import net.pistonmaster.pistonchat.utils.ConfigManager;
 import net.pistonmaster.pistonutils.update.GitHubUpdateChecker;
@@ -28,8 +31,6 @@
 import org.mariadb.jdbc.MariaDbPoolDataSource;
 
 import java.io.IOException;
-import java.sql.Connection;
-import java.sql.SQLException;
 import java.util.logging.Logger;
 
 @Getter
@@ -43,7 +44,7 @@ public final class PistonChat extends JavaPlugin {
     private final HardIgnoreTool hardIgnoreTool = new HardIgnoreTool(this);
     private final CommonTool commonTool = new CommonTool(this);
     private final FoliaLib foliaLib = new FoliaLib(this);
-    private MariaDbPoolDataSource ds;
+    private PCStorage storage;
     private BukkitAudiences adventure;
 
     @Override
@@ -71,30 +72,12 @@ public void onEnable() {
             Bukkit.getPluginManager().disablePlugin(this);
         }
 
-        log.info(ChatColor.DARK_GREEN + "Connecting to database");
-        ds = new MariaDbPoolDataSource();
-        FileConfiguration config = configManager.get();
-        try {
-            ds.setUser(config.getString("mysql.username"));
-            ds.setPassword(config.getString("mysql.password"));
-            ds.setUrl("jdbc:mariadb://" + config.getString("mysql.host") + ":" + config.getInt("mysql.port") +
-                    "/" + config.getString("mysql.database")
-                    + "?sslMode=disable&serverTimezone=UTC&maxPoolSize=10"
-            );
-
-            try (Connection connection = ds.getConnection()) {
-                connection.createStatement().execute("CREATE TABLE IF NOT EXISTS `pistonchat_settings_chat` (`uuid` VARCHAR(36) NOT NULL," +
-                        "`chat_enabled` tinyint(1) NOT NULL," +
-                        "PRIMARY KEY (`uuid`)) ENGINE=InnoDB DEFAULT CHARSET=utf8;");
-                connection.createStatement().execute("CREATE TABLE IF NOT EXISTS `pistonchat_settings_whisper` (`uuid` VARCHAR(36) NOT NULL," +
-                        "`whisper_enabled` tinyint(1) NOT NULL," +
-                        "PRIMARY KEY (`uuid`)) ENGINE=InnoDB DEFAULT CHARSET=utf8;");
-                connection.createStatement().execute("CREATE TABLE IF NOT EXISTS `pistonchat_hard_ignores` (`uuid` VARCHAR(36) NOT NULL," +
-                        "`ignored_uuid` VARCHAR(36) NOT NULL," +
-                        "PRIMARY KEY (`uuid`, `ignored_uuid`)) ENGINE=InnoDB DEFAULT CHARSET=utf8;");
-            }
-        } catch (SQLException e) {
-            e.printStackTrace();
+        log.info(ChatColor.DARK_GREEN + "Loading storage");
+        var storageType = configManager.get().getString("storage");
+        if (storageType.equalsIgnoreCase("mysql")) {
+            storage = new MySQLStorage(log, configManager);
+        } else if (storageType.equalsIgnoreCase("file")) {
+            storage = new FileStorage(log, getDataFolder().toPath());
         }
 
         log.info(ChatColor.DARK_GREEN + "Registering commands");

PistonChat/src/main/java/net/pistonmaster/pistonchat/commands/ignore/HardIgnoreCommand.java

@@ -2,6 +2,7 @@
 
 import lombok.RequiredArgsConstructor;
 import net.pistonmaster.pistonchat.PistonChat;
+import net.pistonmaster.pistonchat.storage.PCStorage;
 import net.pistonmaster.pistonchat.tools.CommonTool;
 import net.pistonmaster.pistonchat.tools.HardIgnoreTool;
 import net.pistonmaster.pistonchat.utils.PlatformUtils;
@@ -38,13 +39,13 @@ public boolean onCommand(CommandSender sender, Command command, String label, St
         }
 
         plugin.runAsync(() -> {
-            HardIgnoreTool.HardReturn type = plugin.getHardIgnoreTool().hardIgnorePlayer(player, ignored.get());
+            PCStorage.HardReturn type = plugin.getHardIgnoreTool().hardIgnorePlayer(player, ignored.get());
 
-            if (type == HardIgnoreTool.HardReturn.IGNORE) {
+            if (type == PCStorage.HardReturn.IGNORE) {
                 plugin.getCommonTool().sendLanguageMessageNoPrefix(player,
                     "ignorehard",
                     CommonTool.getStrippedNameResolver(ignored.get()));
-            } else if (type == HardIgnoreTool.HardReturn.UN_IGNORE) {
+            } else if (type == PCStorage.HardReturn.UN_IGNORE) {
                 plugin.getCommonTool().sendLanguageMessageNoPrefix(player,
                     "unignorehard",
                     CommonTool.getStrippedNameResolver(ignored.get()));

PistonChat/src/main/java/net/pistonmaster/pistonchat/storage/PCStorage.java

@@ -0,0 +1,26 @@
+package net.pistonmaster.pistonchat.storage;
+
+import java.util.List;
+import java.util.UUID;
+
+public interface PCStorage {
+  void setChatEnabled(UUID uuid, boolean enabled);
+
+  boolean isChatEnabled(UUID uuid);
+
+  void setWhisperingEnabled(UUID uuid, boolean enabled);
+
+  boolean isWhisperingEnabled(UUID uuid);
+
+  HardReturn hardIgnorePlayer(UUID ignoringReceiver, UUID ignoredChatter);
+
+  boolean isHardIgnored(UUID chatter, UUID receiver);
+
+  List<UUID> getIgnoredList(UUID uuid);
+
+  void clearIgnoredPlayers(UUID player);
+
+  enum HardReturn {
+    IGNORE, UN_IGNORE
+  }
+}

PistonChat/src/main/java/net/pistonmaster/pistonchat/storage/file/FileStorage.java

@@ -0,0 +1,154 @@
+package net.pistonmaster.pistonchat.storage.file;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.reflect.TypeToken;
+import net.md_5.bungee.api.ChatColor;
+import net.pistonmaster.pistonchat.storage.PCStorage;
+
+import java.io.*;
+import java.lang.reflect.Type;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.logging.Logger;
+
+public class FileStorage implements PCStorage {
+    private final Logger log;
+    private final Gson gson;
+
+    private final Path chatSettingsFile;
+    private final Path whisperSettingsFile;
+    private final Path ignoreListFile;
+
+    private final Map<UUID, Boolean> chatSettings = new ConcurrentHashMap<>();
+    private final Map<UUID, Boolean> whisperSettings = new ConcurrentHashMap<>();
+    private final Map<UUID, List<UUID>> ignoreList = new ConcurrentHashMap<>();
+
+    public FileStorage(Logger log, Path dataFolder) {
+        this.log = log;
+
+        log.info(ChatColor.DARK_GREEN + "Loading file storage");
+
+        gson = new GsonBuilder().setPrettyPrinting().create();
+
+        chatSettingsFile = dataFolder.resolve("chat_settings.json");
+        whisperSettingsFile = dataFolder.resolve("whisper_settings.json");
+        ignoreListFile = dataFolder.resolve("ignore_list.json");
+
+        // Load existing data
+        loadData();
+
+        log.info(ChatColor.DARK_GREEN + "Loaded file storage");
+    }
+
+    private void loadData() {
+        try {
+            // Load chat settings
+            if (Files.exists(chatSettingsFile)) {
+                Type type = new TypeToken<Map<UUID, Boolean>>() {
+                }.getType();
+                try (Reader reader = Files.newBufferedReader(chatSettingsFile, StandardCharsets.UTF_8)) {
+                    Map<UUID, Boolean> loaded = gson.fromJson(reader, type);
+                    if (loaded != null) {
+                        chatSettings.putAll(loaded);
+                    }
+                }
+            }
+
+            // Load whisper settings
+            if (Files.exists(whisperSettingsFile)) {
+                Type type = new TypeToken<Map<UUID, Boolean>>() {
+                }.getType();
+                try (Reader reader = Files.newBufferedReader(whisperSettingsFile, StandardCharsets.UTF_8)) {
+                    Map<UUID, Boolean> loaded = gson.fromJson(reader, type);
+                    if (loaded != null) {
+                        whisperSettings.putAll(loaded);
+                    }
+                }
+            }
+
+            // Load ignore lists
+            if (Files.exists(ignoreListFile)) {
+                Type type = new TypeToken<Map<UUID, List<UUID>>>() {
+                }.getType();
+                try (Reader reader = Files.newBufferedReader(ignoreListFile, StandardCharsets.UTF_8)) {
+                    Map<UUID, List<UUID>> loaded = gson.fromJson(reader, type);
+                    if (loaded != null) {
+                        ignoreList.putAll(loaded);
+                    }
+                }
+            }
+        } catch (Exception e) {
+            log.severe("Error loading data: " + e.getMessage());
+        }
+    }
+
+    private void saveMap(Map<?, ?> data, Path file) {
+        try {
+            Files.createDirectories(file.getParent());
+            try (Writer writer = Files.newBufferedWriter(file, StandardCharsets.UTF_8)) {
+                gson.toJson(data, writer);
+            }
+        } catch (IOException e) {
+            log.severe("Could not save data: " + e.getMessage());
+        }
+    }
+
+    @Override
+    public void setChatEnabled(UUID uuid, boolean enabled) {
+        chatSettings.put(uuid, enabled);
+        saveMap(chatSettings, chatSettingsFile);
+    }
+
+    @Override
+    public boolean isChatEnabled(UUID uuid) {
+        return chatSettings.getOrDefault(uuid, true);
+    }
+
+    @Override
+    public void setWhisperingEnabled(UUID uuid, boolean enabled) {
+        whisperSettings.put(uuid, enabled);
+        saveMap(whisperSettings, whisperSettingsFile);
+    }
+
+    @Override
+    public boolean isWhisperingEnabled(UUID uuid) {
+        return whisperSettings.getOrDefault(uuid, true);
+    }
+
+    @Override
+    public HardReturn hardIgnorePlayer(UUID ignoringReceiver, UUID ignoredChatter) {
+        List<UUID> ignored = ignoreList.computeIfAbsent(ignoringReceiver, k -> new ArrayList<>());
+
+        if (ignored.contains(ignoredChatter)) {
+            ignored.remove(ignoredChatter);
+            saveMap(ignoreList, ignoreListFile);
+            return HardReturn.UN_IGNORE;
+        } else {
+            ignored.add(ignoredChatter);
+            saveMap(ignoreList, ignoreListFile);
+            return HardReturn.IGNORE;
+        }
+    }
+
+    @Override
+    public boolean isHardIgnored(UUID chatter, UUID receiver) {
+        List<UUID> ignored = ignoreList.get(receiver);
+        return ignored != null && ignored.contains(chatter);
+    }
+
+    @Override
+    public List<UUID> getIgnoredList(UUID uuid) {
+        List<UUID> ignored = ignoreList.get(uuid);
+        return ignored != null ? new ArrayList<>(ignored) : new ArrayList<>();
+    }
+
+    @Override
+    public void clearIgnoredPlayers(UUID player) {
+        ignoreList.remove(player);
+        saveMap(ignoreList, ignoreListFile);
+    }
+}