getUUIDFromName(String username) {
+
+ username = username.toLowerCase();
+
+ synchronized (mapNameUUID) {
+ if (mapNameUUID.containsKey(username)) {
+ return Optional.of(mapNameUUID.get(username));
+ }
+ }
+
+ return Optional.empty();
+
+ }
+
+ /**
+ * Register a player as online
+ * Also performs any setup needed to equip nicknames etc.
+ * @param player
+ */
+ public void registerPlayer(Player player) {
+
+ UUID uuid = player.getUniqueId();
+ String username = player.getName();
+ String oldUsername;
+
+ synchronized (mapUUIDName) {
+
+ if (mapUUIDName.containsKey(uuid)) {
+
+ oldUsername = mapUUIDName.get(uuid);
+
+ if (!oldUsername.equalsIgnoreCase(username)) {
+
+ synchronized (mapNameUUID) {
+
+ mapUUIDName.remove(uuid);
+ mapUUIDName.put(uuid, username.toLowerCase());
+ mapNameUUID.remove(oldUsername);
+ mapNameUUID.put(username.toLowerCase(), uuid);
+
+ }
+
+ }
+
+ mapNameFormatted.remove(oldUsername);
+ mapNameFormatted.put(username.toLowerCase(), username);
+
+ } else {
+
+ synchronized (mapNameUUID) {
+
+ mapUUIDName.put(uuid, username.toLowerCase());
+ mapNameUUID.put(username.toLowerCase(), uuid);
+ mapNameFormatted.put(username.toLowerCase(), username);
+
+ }
+
+ }
+
+ }
+
+ online.add(uuid);
+ Bukkit.getLogger().info("[+] " + username + " has joined this server.");
+
+ }
+
+ /**
+ * Register a player into the system without them being online
+ * Used mainly for legacy conversion of old nickname file
+ * @param uuid Player's UUID
+ */
+ public void registerOfflinePlayerByUUID(UUID uuid, String username) {
+
+ synchronized (mapUUIDName) {
+
+ if (mapUUIDName.containsKey(uuid)) {
+
+ /*
+ * EMPTY : Player does not need registering
+ */
+
+ } else {
+
+ synchronized (mapNameUUID) {
+
+ mapUUIDName.put(uuid, username.toLowerCase());
+ mapNameUUID.put(username.toLowerCase(), uuid);
+ mapNameFormatted.put(username.toLowerCase(), username);
+
+ }
+
+ }
+
+ }
+
+ }
+
+ /**
+ * Register a player as offline
+ * @param player
+ */
+ public void unregisterPlayer(Player player) {
+
+ online.remove(player.getUniqueId());
+ Bukkit.getLogger().info("[-] " + player.getName() + " has left this server.");
+
+ }
+
+ /**
+ * Set the nickname of a player
+ * @param uuid
+ * @param nickname
+ */
+ public void setNickname(UUID uuid, String nickname) {
+
+ if (!mapUUIDName.containsKey(uuid)) {
+ return;
+ }
+
+ if (mapUUIDNick.containsKey(uuid)) {
+ removeNickname(uuid);
+ }
+
+ String unformattedNickname = stripAllFormattingCodes(nickname.toLowerCase());
+
+ synchronized (mapNickUUID) {
+
+ // Check for duplicates
+ if (mapNickUUID.containsKey(unformattedNickname)) {
+ if (mapNickUUID.get(unformattedNickname) != uuid) {
+ return;
+ }
+ }
+
+ mapUUIDNick.put(uuid, unformattedNickname);
+ mapNickUUID.put(unformattedNickname, uuid);
+ mapNickFormatted.put(unformattedNickname, nickname);
+
+ }
+
+ }
+
+ /**
+ * @param username
+ * @return If this player has logged into the server before
+ */
+ public boolean existsPlayer(String username) {
+ return mapNameUUID.containsKey(username.toLowerCase());
+ }
+
+ /**
+ * @param nickname
+ * @return If this nickname is currently in use
+ */
+ public boolean existsNickname(String nickname) {
+ return mapNickUUID.containsKey(stripAllFormattingCodes(nickname.toLowerCase()));
+ }
+
+ /**
+ * Return the UUIDs of players who have nicknames containing characters provided in the nickname argument
+ * @param nickname The characters of the nickname to check
+ * @return An optional which might contain a players UUID if a partial match was found
+ */
+ public Optional> getPartialNicknameMatches(String nickname) {
+
+ Set nickSet = mapNickUUID.keySet();
+ nickname = stripAllFormattingCodes(nickname.toLowerCase());
+ Set uuidSet = new HashSet();
+
+ for (String nick : nickSet) {
+
+ if (nick.startsWith(nickname)) {
+ uuidSet.add(mapNickUUID.get(nick));
+ }
+
+ }
+
+ if (!uuidSet.isEmpty()) return Optional.of(uuidSet);
+
+ for (String nick : nickSet) {
+
+ if (nick.contains(nickname)) {
+ uuidSet.add(mapNickUUID.get(nick));
+ }
+
+ }
+
+ if (!uuidSet.isEmpty()) return Optional.of(uuidSet);
+
+ try {
+ for (String nick : nickSet) {
+
+ if (nick.matches(nickname)) {
+ uuidSet.add(mapNickUUID.get(nick));
+ }
+
+ }
+ } catch (PatternSyntaxException e) {
+ /*
+ * Its not a valid regex, so we will just say there are no matches!
+ */
+ }
+
+ if (!uuidSet.isEmpty()) return Optional.of(uuidSet);
+
+ return Optional.empty();
+
+ }
+
+ /**
+ * Return the UUIDs of players who have names containing characters provided in the name argument
+ * @param name The characters of the name to check
+ * @return An optional which might contain a players UUID if a partial match was found
+ */
+ public Optional> getPartialNameMatches(String name) {
+
+ Set nameSet = mapNameUUID.keySet();
+ name = stripAllFormattingCodes(name.toLowerCase());
+ Set uuidSet = new HashSet();
+
+ for (String n : nameSet) {
+
+ if (n.startsWith(name)) {
+ uuidSet.add(mapNameUUID.get(n));
+ }
+
+ }
+
+ if (!uuidSet.isEmpty()) return Optional.of(uuidSet);
+
+ for (String n : nameSet) {
+
+ if (n.contains(name)) {
+ uuidSet.add(mapNameUUID.get(n));
+ }
+
+ }
+
+ if (!uuidSet.isEmpty()) return Optional.of(uuidSet);
+
+ try {
+ for (String n : nameSet) {
+
+ if (n.matches(name)) {
+ uuidSet.add(mapNameUUID.get(n));
+ }
+
+ }
+ } catch (PatternSyntaxException e) {
+ /*
+ * Its not a valid regex, so we will just say there are no matches!
+ */
+ }
+
+ if (!uuidSet.isEmpty()) return Optional.of(uuidSet);
+
+ return Optional.empty();
+
+ }
+
+ /**
+ * @param uuid
+ * @return If this player is currently online on the server
+ */
+ public boolean isOnline(UUID uuid) {
+ return online.contains(uuid);
+ }
+
+ /**
+ * Removes the nickname for a specified player
+ * @param uuid
+ */
+ public void removeNickname(UUID uuid) {
+
+ synchronized (mapUUIDNick) {
+
+ if (!mapUUIDNick.containsKey(uuid)) {
+ return;
+ }
+
+ String nickname = mapUUIDNick.get(uuid);
+
+ mapUUIDNick.remove(uuid);
+ mapNickUUID.remove(nickname);
+ mapNickFormatted.remove(nickname);
+
+ }
+
+ }
+
+ /**
+ * Save all persistent nickname data to file
+ *
+ * @param saveFile The file output stream to use
+ */
+ public void saveNicknameData(FileOutputStream saveFile) {
+
+ try {
+
+ ObjectOutputStream out = new ObjectOutputStream(saveFile);
+
+ out.writeObject(mapUUIDNick);
+ out.writeObject(mapUUIDName);
+ out.writeObject(mapNickUUID);
+ out.writeObject(mapNameUUID);
+ out.writeObject(mapNickFormatted);
+ out.writeObject(mapNameFormatted);
+
+ out.close();
+ Bukkit.getLogger().info("The nicknames file was successfully saved!");
+
+ } catch (IOException e) {
+
+ Bukkit.getLogger().info("An error has occured writing the nicknames file!");
+ e.printStackTrace();
+
+ }
+
+ }
+
+ // /**
+ // * Save all persistent nickname data to file
+ // *
+ // * @param configLoader Configuration file loader to use
+ // */
+ // @SuppressWarnings("serial")
+ // public void SPONGE_saveNicknameData(ConfigurationLoader configLoader) {
+ //
+ // ConfigurationNode rootNode;
+ //
+ // rootNode = configLoader.createEmptyNode();
+ //
+ // try {
+ //
+ // rootNode.getNode("nickname_uuidnick").setValue(new TypeToken>() {}, mapUUIDNick);
+ // rootNode.getNode("nickname_uuidname").setValue(new TypeToken>() {}, mapUUIDName);
+ // rootNode.getNode("nickname_nickuuid").setValue(new TypeToken>() {}, mapNickUUID);
+ // rootNode.getNode("nickname_nameuuid").setValue(new TypeToken>() {}, mapNameUUID);
+ // rootNode.getNode("nickname_nickformatted").setValue(new TypeToken>() {}, mapNickFormatted);
+ // rootNode.getNode("nickname_nameformatted").setValue(new TypeToken>() {}, mapNameFormatted);
+ //
+ // try {
+ //
+ // configLoader.save(rootNode);
+ //
+ // } catch (IOException e) {
+ // e.printStackTrace();
+ // }
+ //
+ // } catch (ObjectMappingException e) {
+ //
+ // e.printStackTrace();
+ // System.err.println("[MultiChatSponge] ERROR: Could not write nicknames :(");
+ //
+ // }
+ //
+ // }
+
+ /**
+ * Load (or attempt to load) nickname data saved to file
+ *
+ * @param saveFile The file input stream to use
+ */
+ @SuppressWarnings({ "unchecked" })
+ public void loadNicknameData(FileInputStream saveFile) {
+
+ try {
+
+ ObjectInputStream in = new ObjectInputStream(saveFile);
+
+ mapUUIDNick = (Map) in.readObject();
+ mapUUIDName = (Map) in.readObject();
+ mapNickUUID = (Map) in.readObject();
+ mapNameUUID = (Map) in.readObject();
+ mapNickFormatted = (Map) in.readObject();
+ mapNameFormatted = (Map) in.readObject();
+
+ in.close();
+
+ Bukkit.getLogger().info("The nicknames file was successfully loaded!");
+
+ } catch (IOException|ClassNotFoundException e) {
+
+ Bukkit.getLogger().info("An error has occured reading the nicknames file!");
+ e.printStackTrace();
+
+ }
+
+ }
+
+ // /**
+ // * Load (or attempt to load) nickname data saved to file
+ // *
+ // * @param configLoader The configuration loader to use
+ // */
+ // @SuppressWarnings("serial")
+ // public void SPONGE_loadNicknameData(ConfigurationLoader configLoader) {
+ //
+ // ConfigurationNode rootNode;
+ //
+ // try {
+ //
+ // rootNode = configLoader.load();
+ //
+ // try {
+ //
+ // mapUUIDNick = (Map) rootNode.getNode("nickname_uuidnick").getValue(new TypeToken>() { /* EMPTY */ });
+ // mapUUIDName = (Map) rootNode.getNode("nickname_uuidname").getValue(new TypeToken>() { /* EMPTY */ });
+ // mapNickUUID = (Map) rootNode.getNode("nickname_nickuuid").getValue(new TypeToken>() { /* EMPTY */ });
+ // mapNameUUID = (Map) rootNode.getNode("nickname_nameuuid").getValue(new TypeToken>() { /* EMPTY */ });
+ // mapNickFormatted = (Map) rootNode.getNode("nickname_nickformatted").getValue(new TypeToken>() { /* EMPTY */ });
+ // mapNameFormatted = (Map) rootNode.getNode("nickname_nameformatted").getValue(new TypeToken>() { /* EMPTY */ });
+ //
+ // if (mapUUIDNick == null) mapUUIDNick = new HashMap();
+ // if (mapUUIDName == null) mapUUIDName = new HashMap();
+ // if (mapNickUUID == null) mapNickUUID = new HashMap();
+ // if (mapNameUUID == null) mapNameUUID = new HashMap();
+ // if (mapNickFormatted == null) mapNickFormatted = new HashMap();
+ // if (mapNameFormatted == null) mapNameFormatted = new HashMap();
+ //
+ //
+ // System.out.println("[MultiChatSponge] Nickname data loaded");
+ //
+ // } catch (ClassCastException e) {
+ //
+ // setDefaultData();
+ //
+ // } catch (ObjectMappingException e) {
+ //
+ // setDefaultData();
+ //
+ // }
+ //
+ // try {
+ //
+ // configLoader.save(rootNode);
+ //
+ // } catch (IOException e) {
+ //
+ // e.printStackTrace();
+ //
+ // }
+ //
+ // } catch (IOException e) {
+ //
+ // e.printStackTrace();
+ // setDefaultData();
+ //
+ // }
+ //
+ // }
+
+}
diff --git a/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/MultiChatSpigot.java b/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/MultiChatSpigot.java
index 5a1c2d44..0ef0dc10 100644
--- a/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/MultiChatSpigot.java
+++ b/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/MultiChatSpigot.java
@@ -6,11 +6,13 @@
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
+import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
+import java.util.Queue;
import java.util.Set;
import java.util.UUID;
@@ -22,6 +24,8 @@
import org.bukkit.plugin.java.JavaPlugin;
import net.milkbowl.vault.chat.Chat;
+import xyz.olivermartin.multichat.database.DatabaseManager;
+import xyz.olivermartin.multichat.database.DatabaseMode;
import xyz.olivermartin.multichat.spigotbridge.commands.CommandHandler;
import xyz.olivermartin.multichat.spigotbridge.listeners.ChatListenerHighest;
import xyz.olivermartin.multichat.spigotbridge.listeners.ChatListenerLowest;
@@ -55,6 +59,8 @@ public class MultiChatSpigot extends JavaPlugin implements Listener {
public static Map placeholderMap = new HashMap();
+ public static Map> chatQueues = new HashMap>();
+
public static Optional getVaultChat() {
if (chat == null) return Optional.empty();
return Optional.of(chat);
@@ -70,7 +76,7 @@ public static boolean hookedPAPI() {
public static File configDir;
- private static final String nameDataFile = "namedata.dat";
+ public static final String nameDataFile = "namedata.dat";
private static File legacyNicknameFile;
public static boolean setDisplayNameLastVal = false;
@@ -89,14 +95,16 @@ public static boolean hookedPAPI() {
public static String nicknamePrefix = "~";
public static List nicknameBlacklist = new ArrayList();
public static int nicknameMaxLength = 20;
+ public static int nicknameMinLength = 3;
public static boolean nicknameLengthIncludeFormatting = false;
+ public static boolean nicknameSQL = false;
@SuppressWarnings("unchecked")
public void onEnable() {
// Read nickname data
- configDir = getDataFolder();
+ configDir = getDataFolder().getAbsoluteFile();
legacyNicknameFile = new File(configDir, "Nicknames.dat");
if (!getDataFolder().exists()) {
@@ -104,8 +112,16 @@ public void onEnable() {
getDataFolder().mkdirs();
configDir = getDataFolder();
}
+
+ String translationsDir = configDir.toString() + File.separator + "translations";
+ if (!new File(translationsDir).exists()) {
+ getLogger().info(logPrefix + "Creating translations directory!");
+ new File(translationsDir).mkdirs();
+ }
SpigotConfigManager.getInstance().registerHandler("spigotconfig.yml", configDir);
+ SpigotConfigManager.getInstance().registerHandler("spigotconfig_fr.yml", new File(translationsDir));
+
Configuration config = SpigotConfigManager.getInstance().getHandler("spigotconfig.yml").getConfig();
if (config.contains("server_name")) {
@@ -139,94 +155,177 @@ public void onEnable() {
nicknameLengthIncludeFormatting = config.getBoolean("nickname_length_limit_formatting");
}
- }
+ if (config.contains("nickname_length_min")) {
- File f = new File(configDir, nameDataFile);
+ nicknameMinLength = config.getInt("nickname_length_min");
- if ((f.exists()) && (!f.isDirectory())) {
+ }
+ if (config.contains("nickname_sql")) {
- getLogger().info(logPrefix + "Attempting startup load for Nicknames");
+ nicknameSQL = config.getBoolean("nickname_sql");
- File file = new File(configDir, nameDataFile);
- FileInputStream saveFile;
- try {
- saveFile = new FileInputStream(file);
- NameManager.getInstance().loadNicknameData(saveFile);
- } catch (FileNotFoundException e) {
- getLogger().info(logPrefix + "[ERROR] Could not load nickname data");
- e.printStackTrace();
- }
+ if (nicknameSQL) {
- getLogger().info(logPrefix + "Load completed!");
+ if (config.getBoolean("mysql")) {
- } else if (legacyNicknameFile.exists()) {
+ DatabaseManager.getInstance().setMode(DatabaseMode.MySQL);
- // LEGACY NICKNAME FILE HANDLING --------------------------------------------
+ DatabaseManager.getInstance().setURLMySQL(config.getString("mysql_url"));
+ DatabaseManager.getInstance().setUsernameMySQL(config.getString("mysql_user"));
+ DatabaseManager.getInstance().setPasswordMySQL(config.getString("mysql_pass"));
- HashMap result = null;
+ try {
- try {
+ if (config.contains("mysql_database")) {
+ DatabaseManager.getInstance().createDatabase("multichatspigot.db", config.getString("mysql_database"));
+ } else {
+ DatabaseManager.getInstance().createDatabase("multichatspigot.db", "multichatspigot");
+ }
+
+ DatabaseManager.getInstance().getDatabase("multichatspigot.db").get().connectToDatabase();
+ DatabaseManager.getInstance().getDatabase("multichatspigot.db").get().update("CREATE TABLE IF NOT EXISTS name_data(id VARCHAR(128), f_name VARCHAR(255), u_name VARCHAR(255), PRIMARY KEY (id));");
+ DatabaseManager.getInstance().getDatabase("multichatspigot.db").get().update("CREATE TABLE IF NOT EXISTS nick_data(id VARCHAR(128), u_nick VARCHAR(255), f_nick VARCHAR(255), PRIMARY KEY (id));");
+ DatabaseManager.getInstance().getDatabase("multichatspigot.db").get().disconnectFromDatabase();
- FileInputStream saveFile = new FileInputStream(legacyNicknameFile);
- ObjectInputStream in = new ObjectInputStream(saveFile);
- result = (HashMap) in.readObject();
- in.close();
- getLogger().info(logPrefix + "Loaded a legacy (pre 1.6) nicknames file. Attempting conversion...");
+ NameManager.useSQL(nicknameSQL);
- int counter = 0;
+ } catch (SQLException e) {
+ nicknameSQL = false;
+ NameManager.useSQL(false);
+ System.err.println("Could not enable database! Using files...");
+ e.printStackTrace();
+ }
+
+ } else {
+
+ DatabaseManager.getInstance().setMode(DatabaseMode.SQLite);
- if (result != null) {
+ DatabaseManager.getInstance().setPathSQLite(configDir);
- if (result.keySet() != null) {
+ try {
- for (UUID u : result.keySet()) {
+ DatabaseManager.getInstance().createDatabase("multichatspigot.db");
- counter++;
- NameManager.getInstance().registerOfflinePlayerByUUID(u, "NotJoinedYet"+String.valueOf(counter));
- NameManager.getInstance().setNickname(u, result.get(u));
+ DatabaseManager.getInstance().getDatabase("multichatspigot.db").get().connectToDatabase();
+ DatabaseManager.getInstance().getDatabase("multichatspigot.db").get().update("CREATE TABLE IF NOT EXISTS name_data(id VARCHAR(128), f_name VARCHAR(255), u_name VARCHAR(255), PRIMARY KEY (id));");
+ DatabaseManager.getInstance().getDatabase("multichatspigot.db").get().update("CREATE TABLE IF NOT EXISTS nick_data(id VARCHAR(128), u_nick VARCHAR(255), f_nick VARCHAR(255), PRIMARY KEY (id));");
+ DatabaseManager.getInstance().getDatabase("multichatspigot.db").get().disconnectFromDatabase();
+ NameManager.useSQL(nicknameSQL);
+
+ } catch (SQLException e) {
+ nicknameSQL = false;
+ NameManager.useSQL(false);
+ System.err.println("Could not enable database! Using files...");
+ e.printStackTrace();
}
}
}
+ }
+ }
+
+ // If we are using File Based name storage
+ if (NameManager.getInstance() instanceof FileNameManager) {
+
+ File f = new File(configDir, nameDataFile);
+
+ if ((f.exists()) && (!f.isDirectory())) {
+
+ getLogger().info(logPrefix + "Attempting startup load for Nicknames");
+
File file = new File(configDir, nameDataFile);
- FileOutputStream saveFile2;
+ FileInputStream saveFile;
try {
- saveFile2 = new FileOutputStream(file);
- NameManager.getInstance().saveNicknameData(saveFile2);
+ saveFile = new FileInputStream(file);
+ if (NameManager.getInstance() instanceof FileNameManager) {
+ ((FileNameManager)NameManager.getInstance()).loadNicknameData(saveFile);
+ }
+
} catch (FileNotFoundException e) {
- getLogger().info(logPrefix + "[ERROR] Could not save nickname data");
+ getLogger().info(logPrefix + "[ERROR] Could not load nickname data");
e.printStackTrace();
}
- getLogger().info(logPrefix + "The files were created!");
+ getLogger().info(logPrefix + "Load completed!");
- } catch (IOException|ClassNotFoundException e) {
+ } else if (legacyNicknameFile.exists()) {
- getLogger().info(logPrefix + "[ERROR] An error has occured reading the legacy nicknames file. Please delete it.");
- e.printStackTrace();
+ // LEGACY NICKNAME FILE HANDLING --------------------------------------------
- }
+ HashMap result = null;
- } else {
+ try {
- getLogger().info(logPrefix + "Name data files do not exist to load. Must be first startup!");
- getLogger().info(logPrefix + "Enabling Nicknames! :D");
- getLogger().info(logPrefix + "Attempting to create hash files!");
+ FileInputStream saveFile = new FileInputStream(legacyNicknameFile);
+ ObjectInputStream in = new ObjectInputStream(saveFile);
+ result = (HashMap) in.readObject();
+ in.close();
+ getLogger().info(logPrefix + "Loaded a legacy (pre 1.6) nicknames file. Attempting conversion...");
- File file = new File(configDir, nameDataFile);
- FileOutputStream saveFile;
- try {
- saveFile = new FileOutputStream(file);
- NameManager.getInstance().saveNicknameData(saveFile);
- } catch (FileNotFoundException e) {
- getLogger().info(logPrefix + "[ERROR] Could not save nickname data");
- e.printStackTrace();
- }
+ int counter = 0;
- getLogger().info(logPrefix + "The files were created!");
+ if (result != null) {
+
+ if (result.keySet() != null) {
+
+ for (UUID u : result.keySet()) {
+
+ counter++;
+ NameManager.getInstance().registerOfflinePlayerByUUID(u, "NotJoinedYet"+String.valueOf(counter));
+ NameManager.getInstance().setNickname(u, result.get(u));
+
+ }
+
+ }
+
+ }
+
+ File file = new File(configDir, nameDataFile);
+ FileOutputStream saveFile2;
+ try {
+ saveFile2 = new FileOutputStream(file);
+ if (NameManager.getInstance() instanceof FileNameManager) {
+ ((FileNameManager)NameManager.getInstance()).saveNicknameData(saveFile2);
+ }
+ } catch (FileNotFoundException e) {
+ getLogger().info(logPrefix + "[ERROR] Could not save nickname data");
+ e.printStackTrace();
+ }
+
+ getLogger().info(logPrefix + "The files were created!");
+
+ } catch (IOException|ClassNotFoundException e) {
+
+ getLogger().info(logPrefix + "[ERROR] An error has occured reading the legacy nicknames file. Please delete it.");
+ e.printStackTrace();
+
+ }
+
+ } else {
+
+ getLogger().info(logPrefix + "Name data files do not exist to load. Must be first startup!");
+ getLogger().info(logPrefix + "Enabling Nicknames! :D");
+ getLogger().info(logPrefix + "Attempting to create hash files!");
+
+ File file = new File(configDir, nameDataFile);
+ FileOutputStream saveFile;
+ try {
+ saveFile = new FileOutputStream(file);
+ if (NameManager.getInstance() instanceof FileNameManager) {
+ ((FileNameManager)NameManager.getInstance()).saveNicknameData(saveFile);
+ }
+
+ } catch (FileNotFoundException e) {
+ getLogger().info(logPrefix + "[ERROR] Could not save nickname data");
+ e.printStackTrace();
+ }
+
+ getLogger().info(logPrefix + "The files were created!");
+
+ }
}
@@ -239,6 +338,8 @@ public void onEnable() {
getServer().getMessenger().registerOutgoingPluginChannel(this, "multichat:dn");
getServer().getMessenger().registerOutgoingPluginChannel(this, "multichat:world");
getServer().getMessenger().registerOutgoingPluginChannel(this, "multichat:nick");
+ getServer().getMessenger().registerOutgoingPluginChannel(this, "multichat:pxe");
+ getServer().getMessenger().registerOutgoingPluginChannel(this, "multichat:ppxe");
getServer().getMessenger().registerIncomingPluginChannel(this, "multichat:comm", MultiChatPluginMessageListener.getInstance());
getServer().getMessenger().registerIncomingPluginChannel(this, "multichat:chat", MultiChatPluginMessageListener.getInstance());
getServer().getMessenger().registerIncomingPluginChannel(this, "multichat:act", MultiChatPluginMessageListener.getInstance());
@@ -262,6 +363,8 @@ public void onEnable() {
this.getCommand("realname").setExecutor(CommandHandler.getInstance());
this.getCommand("username").setExecutor(CommandHandler.getInstance());
this.getCommand("multichatspigot").setExecutor(CommandHandler.getInstance());
+ this.getCommand("pxe").setExecutor(CommandHandler.getInstance());
+ this.getCommand("pexecute").setExecutor(CommandHandler.getInstance());
// Manage dependencies
@@ -308,15 +411,28 @@ private boolean setupPAPI() {
public void onDisable() {
- File file = new File(configDir, nameDataFile);
- FileOutputStream saveFile;
- try {
- saveFile = new FileOutputStream(file);
- NameManager.getInstance().saveNicknameData(saveFile);
- } catch (FileNotFoundException e) {
- getLogger().info(logPrefix + "[ERROR] Could not save nickname data");
- e.printStackTrace();
+ if (nicknameSQL) {
+ try {
+ DatabaseManager.getInstance().getDatabase("multichatspigot.db").get().disconnectFromDatabase();
+ } catch (SQLException e1) {
+ e1.printStackTrace();
+ }
+ } else {
+
+ File file = new File(configDir, nameDataFile);
+ FileOutputStream saveFile;
+ try {
+ saveFile = new FileOutputStream(file);
+ if (NameManager.getInstance() instanceof FileNameManager) {
+ ((FileNameManager)NameManager.getInstance()).saveNicknameData(saveFile);
+ }
+ } catch (FileNotFoundException e) {
+ getLogger().info(logPrefix + "[ERROR] Could not save nickname data");
+ e.printStackTrace();
+ }
+
}
+
}
}
diff --git a/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/NameManager.java b/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/NameManager.java
index bff56e6c..efec793e 100644
--- a/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/NameManager.java
+++ b/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/NameManager.java
@@ -1,22 +1,12 @@
package xyz.olivermartin.multichat.spigotbridge;
-import java.io.FileInputStream;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.HashSet;
import java.util.List;
-import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.UUID;
import java.util.regex.Pattern;
-import java.util.regex.PatternSyntaxException;
-import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
@@ -30,50 +20,33 @@
* @author Oliver Martin (Revilo410)
*
*/
-public class NameManager implements Listener {
-
+public abstract class NameManager implements Listener {
+
private static NameManager instance;
static {
- instance = new NameManager();
+ instance = new FileNameManager();
}
public static NameManager getInstance() {
return instance;
}
+
+ public static void useSQL(boolean sql) {
+ if (sql) instance = new SQLNameManager();
+ else instance = new FileNameManager();
+ }
// END OF STATIC DEFINITIONS
- private Map mapUUIDNick;
- private Map mapUUIDName;
- private Map mapNickUUID;
- private Map mapNameUUID;
-
- private Map mapNickFormatted;
- private Map mapNameFormatted;
-
- private List online;
+ protected List online;
- private NameManager() {
-
- setDefaultData();
+ protected NameManager() {
online = new ArrayList();
}
- private void setDefaultData() {
-
- mapUUIDNick = new HashMap();
- mapUUIDName = new HashMap();
- mapNickUUID = new HashMap();
- mapNameUUID = new HashMap();
-
- mapNickFormatted = new HashMap();
- mapNameFormatted = new HashMap();
-
- }
-
/**
* Returns the FORMATTED NICKNAME of a player if they have one set, otherwise returns their username
*
@@ -91,26 +64,7 @@ public String getCurrentName(UUID uuid) {
* @param withPrefix Should the nickname prefix also be returned if it is set?
* @return The NICKNAME of the player if it is set, otherwise their username
*/
- public String getCurrentName(UUID uuid, boolean withPrefix) {
-
- synchronized (mapUUIDNick) {
- if (mapUUIDNick.containsKey(uuid)) {
- if (MultiChatSpigot.showNicknamePrefix && withPrefix) {
- return MultiChatSpigot.nicknamePrefix + mapNickFormatted.get(mapUUIDNick.get(uuid));
- } else {
- return mapNickFormatted.get(mapUUIDNick.get(uuid));
- }
- }
- }
-
- synchronized (mapUUIDName) {
- if (mapUUIDName.containsKey(uuid)) {
- return mapNameFormatted.get(mapUUIDName.get(uuid));
- }
- }
-
- return "";
- }
+ public abstract String getCurrentName(UUID uuid, boolean withPrefix);
/**
* Returns the username of a player
@@ -118,17 +72,7 @@ public String getCurrentName(UUID uuid, boolean withPrefix) {
* @param uuid The Unique ID of the player to lookup
* @return The username of the player
*/
- public String getName(UUID uuid) {
-
- synchronized (mapUUIDName) {
- if (mapUUIDName.containsKey(uuid)) {
- return mapNameFormatted.get(mapUUIDName.get(uuid));
- }
- }
-
- return "";
-
- }
+ public abstract String getName(UUID uuid);
/**
* Gets the UUID of a player from their UNFORMATTED nickname
@@ -137,19 +81,7 @@ public String getName(UUID uuid) {
* @param nickname The UNFORMATTED nickname of the player
* @return An optional which may contain their UUID if the nickname was found in the system
*/
- private Optional getUUIDFromUnformattedNickname(String nickname) {
-
- nickname = nickname.toLowerCase();
-
- synchronized (mapNickUUID) {
- if (mapNickUUID.containsKey(nickname)) {
- return Optional.of(mapNickUUID.get(nickname));
- }
- }
-
- return Optional.empty();
-
- }
+ protected abstract Optional getUUIDFromUnformattedNickname(String nickname);
/**
* Returns a player's UUID given their username
@@ -157,19 +89,7 @@ private Optional getUUIDFromUnformattedNickname(String nickname) {
* @param username The player's username
* @return An optional value which may contain their UUID if the username was found
*/
- public Optional getUUIDFromName(String username) {
-
- username = username.toLowerCase();
-
- synchronized (mapNameUUID) {
- if (mapNameUUID.containsKey(username)) {
- return Optional.of(mapNameUUID.get(username));
- }
- }
-
- return Optional.empty();
-
- }
+ public abstract Optional getUUIDFromName(String username);
/**
* Gets a player's UUID from their nickname
@@ -255,246 +175,53 @@ public Optional getFormattedNameFromName(String username) {
* Also performs any setup needed to equip nicknames etc.
* @param player
*/
- public void registerPlayer(Player player) {
-
- UUID uuid = player.getUniqueId();
- String username = player.getName();
- String oldUsername;
-
- synchronized (mapUUIDName) {
-
- if (mapUUIDName.containsKey(uuid)) {
-
- oldUsername = mapUUIDName.get(uuid);
-
- if (!oldUsername.equalsIgnoreCase(username)) {
-
- synchronized (mapNameUUID) {
-
- mapUUIDName.remove(uuid);
- mapUUIDName.put(uuid, username.toLowerCase());
- mapNameUUID.remove(oldUsername);
- mapNameUUID.put(username.toLowerCase(), uuid);
-
- }
-
- }
-
- mapNameFormatted.remove(oldUsername);
- mapNameFormatted.put(username.toLowerCase(), username);
-
- } else {
-
- synchronized (mapNameUUID) {
-
- mapUUIDName.put(uuid, username.toLowerCase());
- mapNameUUID.put(username.toLowerCase(), uuid);
- mapNameFormatted.put(username.toLowerCase(), username);
-
- }
-
- }
-
- }
-
- online.add(uuid);
- Bukkit.getLogger().info("[+] " + username + " has joined this server.");
-
- }
+ public abstract void registerPlayer(Player player);
/**
* Register a player into the system without them being online
* Used mainly for legacy conversion of old nickname file
* @param uuid Player's UUID
*/
- public void registerOfflinePlayerByUUID(UUID uuid, String username) {
-
- synchronized (mapUUIDName) {
-
- if (mapUUIDName.containsKey(uuid)) {
-
- /*
- * EMPTY : Player does not need registering
- */
-
- } else {
-
- synchronized (mapNameUUID) {
-
- mapUUIDName.put(uuid, username.toLowerCase());
- mapNameUUID.put(username.toLowerCase(), uuid);
- mapNameFormatted.put(username.toLowerCase(), username);
-
- }
-
- }
-
- }
-
- }
+ public abstract void registerOfflinePlayerByUUID(UUID uuid, String username);
/**
* Register a player as offline
* @param player
*/
- public void unregisterPlayer(Player player) {
-
- online.remove(player.getUniqueId());
- Bukkit.getLogger().info("[-] " + player.getName() + " has left this server.");
-
- }
+ public abstract void unregisterPlayer(Player player);
/**
* Set the nickname of a player
* @param uuid
* @param nickname
*/
- public void setNickname(UUID uuid, String nickname) {
-
- if (!mapUUIDName.containsKey(uuid)) {
- return;
- }
-
- if (mapUUIDNick.containsKey(uuid)) {
- removeNickname(uuid);
- }
-
- String unformattedNickname = stripAllFormattingCodes(nickname.toLowerCase());
-
- synchronized (mapNickUUID) {
-
- // Check for duplicates
- if (mapNickUUID.containsKey(unformattedNickname)) {
- if (mapNickUUID.get(unformattedNickname) != uuid) {
- return;
- }
- }
-
- mapUUIDNick.put(uuid, unformattedNickname);
- mapNickUUID.put(unformattedNickname, uuid);
- mapNickFormatted.put(unformattedNickname, nickname);
-
- }
-
- }
+ public abstract void setNickname(UUID uuid, String nickname);
/**
* @param username
* @return If this player has logged into the server before
*/
- public boolean existsPlayer(String username) {
- return mapNameUUID.containsKey(username.toLowerCase());
- }
+ public abstract boolean existsPlayer(String username);
/**
* @param nickname
* @return If this nickname is currently in use
*/
- public boolean existsNickname(String nickname) {
- return mapNickUUID.containsKey(stripAllFormattingCodes(nickname.toLowerCase()));
- }
+ public abstract boolean existsNickname(String nickname);
/**
* Return the UUIDs of players who have nicknames containing characters provided in the nickname argument
* @param nickname The characters of the nickname to check
* @return An optional which might contain a players UUID if a partial match was found
*/
- public Optional> getPartialNicknameMatches(String nickname) {
-
- Set nickSet = mapNickUUID.keySet();
- nickname = stripAllFormattingCodes(nickname.toLowerCase());
- Set uuidSet = new HashSet();
-
- for (String nick : nickSet) {
-
- if (nick.startsWith(nickname)) {
- uuidSet.add(mapNickUUID.get(nick));
- }
-
- }
-
- if (!uuidSet.isEmpty()) return Optional.of(uuidSet);
-
- for (String nick : nickSet) {
-
- if (nick.contains(nickname)) {
- uuidSet.add(mapNickUUID.get(nick));
- }
-
- }
-
- if (!uuidSet.isEmpty()) return Optional.of(uuidSet);
-
- try {
- for (String nick : nickSet) {
-
- if (nick.matches(nickname)) {
- uuidSet.add(mapNickUUID.get(nick));
- }
-
- }
- } catch (PatternSyntaxException e) {
- /*
- * Its not a valid regex, so we will just say there are no matches!
- */
- }
-
- if (!uuidSet.isEmpty()) return Optional.of(uuidSet);
-
- return Optional.empty();
-
- }
+ public abstract Optional> getPartialNicknameMatches(String nickname);
/**
* Return the UUIDs of players who have names containing characters provided in the name argument
* @param name The characters of the name to check
* @return An optional which might contain a players UUID if a partial match was found
*/
- public Optional> getPartialNameMatches(String name) {
-
- Set nameSet = mapNameUUID.keySet();
- name = stripAllFormattingCodes(name.toLowerCase());
- Set uuidSet = new HashSet();
-
- for (String n : nameSet) {
-
- if (n.startsWith(name)) {
- uuidSet.add(mapNameUUID.get(n));
- }
-
- }
-
- if (!uuidSet.isEmpty()) return Optional.of(uuidSet);
-
- for (String n : nameSet) {
-
- if (n.contains(name)) {
- uuidSet.add(mapNameUUID.get(n));
- }
-
- }
-
- if (!uuidSet.isEmpty()) return Optional.of(uuidSet);
-
- try {
- for (String n : nameSet) {
-
- if (n.matches(name)) {
- uuidSet.add(mapNameUUID.get(n));
- }
-
- }
- } catch (PatternSyntaxException e) {
- /*
- * Its not a valid regex, so we will just say there are no matches!
- */
- }
-
- if (!uuidSet.isEmpty()) return Optional.of(uuidSet);
-
- return Optional.empty();
-
- }
+ public abstract Optional> getPartialNameMatches(String name);
/**
* @param uuid
@@ -508,185 +235,7 @@ public boolean isOnline(UUID uuid) {
* Removes the nickname for a specified player
* @param uuid
*/
- public void removeNickname(UUID uuid) {
-
- synchronized (mapUUIDNick) {
-
- if (!mapUUIDNick.containsKey(uuid)) {
- return;
- }
-
- String nickname = mapUUIDNick.get(uuid);
-
- mapUUIDNick.remove(uuid);
- mapNickUUID.remove(nickname);
- mapNickFormatted.remove(nickname);
-
- }
-
- }
-
- /**
- * Save all persistent nickname data to file
- *
- * @param saveFile The file output stream to use
- */
- public void saveNicknameData(FileOutputStream saveFile) {
-
- try {
-
- ObjectOutputStream out = new ObjectOutputStream(saveFile);
-
- out.writeObject(mapUUIDNick);
- out.writeObject(mapUUIDName);
- out.writeObject(mapNickUUID);
- out.writeObject(mapNameUUID);
- out.writeObject(mapNickFormatted);
- out.writeObject(mapNameFormatted);
-
- out.close();
- Bukkit.getLogger().info("The nicknames file was successfully saved!");
-
- } catch (IOException e) {
-
- Bukkit.getLogger().info("An error has occured writing the nicknames file!");
- e.printStackTrace();
-
- }
-
- }
-
- // /**
- // * Save all persistent nickname data to file
- // *
- // * @param configLoader Configuration file loader to use
- // */
- // @SuppressWarnings("serial")
- // public void SPONGE_saveNicknameData(ConfigurationLoader configLoader) {
- //
- // ConfigurationNode rootNode;
- //
- // rootNode = configLoader.createEmptyNode();
- //
- // try {
- //
- // rootNode.getNode("nickname_uuidnick").setValue(new TypeToken>() {}, mapUUIDNick);
- // rootNode.getNode("nickname_uuidname").setValue(new TypeToken>() {}, mapUUIDName);
- // rootNode.getNode("nickname_nickuuid").setValue(new TypeToken>() {}, mapNickUUID);
- // rootNode.getNode("nickname_nameuuid").setValue(new TypeToken>() {}, mapNameUUID);
- // rootNode.getNode("nickname_nickformatted").setValue(new TypeToken>() {}, mapNickFormatted);
- // rootNode.getNode("nickname_nameformatted").setValue(new TypeToken>() {}, mapNameFormatted);
- //
- // try {
- //
- // configLoader.save(rootNode);
- //
- // } catch (IOException e) {
- // e.printStackTrace();
- // }
- //
- // } catch (ObjectMappingException e) {
- //
- // e.printStackTrace();
- // System.err.println("[MultiChatSponge] ERROR: Could not write nicknames :(");
- //
- // }
- //
- // }
-
- /**
- * Load (or attempt to load) nickname data saved to file
- *
- * @param saveFile The file input stream to use
- */
- @SuppressWarnings({ "unchecked" })
- public void loadNicknameData(FileInputStream saveFile) {
-
- try {
-
- ObjectInputStream in = new ObjectInputStream(saveFile);
-
- mapUUIDNick = (Map) in.readObject();
- mapUUIDName = (Map) in.readObject();
- mapNickUUID = (Map) in.readObject();
- mapNameUUID = (Map) in.readObject();
- mapNickFormatted = (Map) in.readObject();
- mapNameFormatted = (Map) in.readObject();
-
- in.close();
-
- Bukkit.getLogger().info("The nicknames file was successfully loaded!");
-
- } catch (IOException|ClassNotFoundException e) {
-
- Bukkit.getLogger().info("An error has occured reading the nicknames file!");
- e.printStackTrace();
-
- }
-
- }
-
- // /**
- // * Load (or attempt to load) nickname data saved to file
- // *
- // * @param configLoader The configuration loader to use
- // */
- // @SuppressWarnings("serial")
- // public void SPONGE_loadNicknameData(ConfigurationLoader configLoader) {
- //
- // ConfigurationNode rootNode;
- //
- // try {
- //
- // rootNode = configLoader.load();
- //
- // try {
- //
- // mapUUIDNick = (Map) rootNode.getNode("nickname_uuidnick").getValue(new TypeToken>() { /* EMPTY */ });
- // mapUUIDName = (Map) rootNode.getNode("nickname_uuidname").getValue(new TypeToken>() { /* EMPTY */ });
- // mapNickUUID = (Map) rootNode.getNode("nickname_nickuuid").getValue(new TypeToken>() { /* EMPTY */ });
- // mapNameUUID = (Map) rootNode.getNode("nickname_nameuuid").getValue(new TypeToken>() { /* EMPTY */ });
- // mapNickFormatted = (Map) rootNode.getNode("nickname_nickformatted").getValue(new TypeToken>() { /* EMPTY */ });
- // mapNameFormatted = (Map) rootNode.getNode("nickname_nameformatted").getValue(new TypeToken>() { /* EMPTY */ });
- //
- // if (mapUUIDNick == null) mapUUIDNick = new HashMap();
- // if (mapUUIDName == null) mapUUIDName = new HashMap();
- // if (mapNickUUID == null) mapNickUUID = new HashMap();
- // if (mapNameUUID == null) mapNameUUID = new HashMap();
- // if (mapNickFormatted == null) mapNickFormatted = new HashMap();
- // if (mapNameFormatted == null) mapNameFormatted = new HashMap();
- //
- //
- // System.out.println("[MultiChatSponge] Nickname data loaded");
- //
- // } catch (ClassCastException e) {
- //
- // setDefaultData();
- //
- // } catch (ObjectMappingException e) {
- //
- // setDefaultData();
- //
- // }
- //
- // try {
- //
- // configLoader.save(rootNode);
- //
- // } catch (IOException e) {
- //
- // e.printStackTrace();
- //
- // }
- //
- // } catch (IOException e) {
- //
- // e.printStackTrace();
- // setDefaultData();
- //
- // }
- //
- // }
+ public abstract void removeNickname(UUID uuid);
/*
* Remove all colour / format codes from a string (using the '&' char)
diff --git a/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/SQLNameManager.java b/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/SQLNameManager.java
new file mode 100644
index 00000000..5696da6b
--- /dev/null
+++ b/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/SQLNameManager.java
@@ -0,0 +1,676 @@
+package xyz.olivermartin.multichat.spigotbridge;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.HashSet;
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+
+import xyz.olivermartin.multichat.database.DatabaseManager;
+import xyz.olivermartin.multichat.database.GenericDatabase;
+
+public class SQLNameManager extends NameManager {
+
+ private boolean connected;
+ private GenericDatabase spigotdatabase;
+
+ public SQLNameManager() {
+
+ super();
+
+ connected = getDatabase();
+
+ }
+
+ private boolean getDatabase() {
+
+ Optional ogdb = DatabaseManager.getInstance().getDatabase("multichatspigot.db");
+ if (ogdb.isPresent()) {
+ spigotdatabase = ogdb.get();
+ return true;
+ } else {
+ return false;
+ }
+
+ }
+
+ @Override
+ public String getCurrentName(UUID uuid, boolean withPrefix) {
+
+ if (connected) {
+
+ try {
+
+ String name;
+
+ synchronized (spigotdatabase) {
+ spigotdatabase.connectToDatabase();
+ ResultSet results = spigotdatabase.query("SELECT f_name, f_nick FROM name_data LEFT JOIN nick_data ON name_data.id = nick_data.id WHERE name_data.id = '" + uuid.toString() + "';");
+ results.next();
+ if (results.getString("f_nick") == null) {
+ name = results.getString("f_name");
+ } else {
+ name = results.getString("f_nick");
+ }
+ //spigotdatabase.disconnectFromDatabase();
+ }
+
+ if (MultiChatSpigot.showNicknamePrefix && withPrefix) {
+ return MultiChatSpigot.nicknamePrefix + name;
+ } else {
+ return name;
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ return "";
+ }
+
+ } else {
+ System.err.println("NOT CONNECTED TO DB?!?!?!?"); //TODO?
+ return "";
+ }
+
+ }
+
+ @Override
+ public String getName(UUID uuid) {
+
+ if (connected) {
+
+ try {
+ String name;
+ synchronized (spigotdatabase) {
+ spigotdatabase.connectToDatabase();
+ ResultSet results = spigotdatabase.query("SELECT f_name FROM name_data WHERE id = '" + uuid.toString() + "';");
+ results.next();
+ name = results.getString("f_name");
+ //spigotdatabase.disconnectFromDatabase();
+ }
+
+ return name;
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ return "";
+ }
+
+ } else {
+ System.err.println("NOT CONNECTED TO DB?!?!?!?"); //TODO?
+ return "";
+ }
+
+ }
+
+ @Override
+ protected Optional getUUIDFromUnformattedNickname(String nickname) {
+
+ nickname = nickname.toLowerCase();
+
+ if (connected) {
+
+ try {
+
+ synchronized (spigotdatabase) {
+ spigotdatabase.connectToDatabase();
+ ResultSet results = spigotdatabase.query("SELECT id FROM nick_data WHERE u_nick = '" + nickname + "';");
+ if (results.next()) {
+ UUID id = UUID.fromString(results.getString("id"));
+ //spigotdatabase.disconnectFromDatabase();
+ return Optional.of(id);
+ } else {
+ //spigotdatabase.disconnectFromDatabase();
+ return Optional.empty();
+ }
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ return Optional.empty();
+ }
+
+ } else {
+ System.err.println("NOT CONNECTED TO DB?!?!?!?"); //TODO?
+ return Optional.empty();
+ }
+
+ }
+
+ @Override
+ public Optional getUUIDFromName(String username) {
+
+ username = username.toLowerCase();
+
+ if (connected) {
+
+ try {
+
+ synchronized (spigotdatabase) {
+ spigotdatabase.connectToDatabase();
+ ResultSet results = spigotdatabase.query("SELECT id FROM name_data WHERE u_name = '" + username + "';");
+ if (results.next() ) {
+ UUID id = UUID.fromString(results.getString("id"));
+ //spigotdatabase.disconnectFromDatabase();
+ return Optional.of(id);
+ } else {
+ //spigotdatabase.disconnectFromDatabase();
+ return Optional.empty();
+ }
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ return Optional.empty();
+ }
+
+ } else {
+ System.err.println("NOT CONNECTED TO DB?!?!?!?"); //TODO?
+ return Optional.empty();
+ }
+
+ }
+
+ @Override
+ public void registerPlayer(Player player) {
+
+ if (!connected) {
+ System.err.println("NOT CONNECTED TO DB?!?!?!?"); //TODO?
+ return;
+ }
+
+ UUID uuid = player.getUniqueId();
+ String username = player.getName();
+ String oldUsername;
+
+ if (existsUUID(uuid)) {
+
+ oldUsername = getName(uuid);
+
+ if (!oldUsername.equalsIgnoreCase(username)) {
+
+ try {
+ synchronized (spigotdatabase) {
+ spigotdatabase.connectToDatabase();
+
+ spigotdatabase.update("UPDATE name_data SET u_name = '" + username.toLowerCase() + "', f_name = '" + username + "' WHERE id = '" + uuid.toString() + "';");
+
+ //spigotdatabase.disconnectFromDatabase();
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ }
+
+ }
+
+ } else {
+
+ try {
+ synchronized (spigotdatabase) {
+ spigotdatabase.connectToDatabase();
+
+ spigotdatabase.update("INSERT INTO name_data VALUES ('" + uuid.toString() + "', '" + username + "', '" + username.toLowerCase()+ "');");
+
+ //spigotdatabase.disconnectFromDatabase();
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ }
+
+ }
+
+ online.add(uuid);
+ Bukkit.getLogger().info("[+] " + username + " has joined this server.");
+
+ }
+
+ public void testRegisterFakePlayer(UUID uuid, String username) {
+
+ if (!connected) {
+ System.err.println("NOT CONNECTED TO DB?!?!?!?"); //TODO?
+ return;
+ }
+
+ String oldUsername;
+
+ if (existsUUID(uuid)) {
+
+ oldUsername = getName(uuid);
+
+ if (!oldUsername.equalsIgnoreCase(username)) {
+
+ try {
+ synchronized (spigotdatabase) {
+ spigotdatabase.connectToDatabase();
+
+ spigotdatabase.update("UPDATE name_data SET u_name = '" + username.toLowerCase() + "', f_name = '" + username + "' WHERE id = '" + uuid.toString() + "';");
+
+ //spigotdatabase.disconnectFromDatabase();
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ }
+
+ }
+
+ } else {
+
+ try {
+ synchronized (spigotdatabase) {
+ spigotdatabase.connectToDatabase();
+
+ spigotdatabase.update("INSERT INTO name_data VALUES ('" + uuid.toString() + "', '" + username + "', '" + username.toLowerCase() + "');");
+
+ //spigotdatabase.disconnectFromDatabase();
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ }
+
+ }
+
+ online.add(uuid);
+
+ }
+
+ public boolean existsUUID(UUID uuid) {
+
+ if (!connected) {
+ System.err.println("NOT CONNECTED TO DB?!?!?!?"); //TODO?
+ return false;
+ }
+
+ try {
+ synchronized (spigotdatabase) {
+ spigotdatabase.connectToDatabase();
+
+ ResultSet results = spigotdatabase.query("SELECT id FROM name_data WHERE id = '" + uuid.toString() + "';");
+ if (results.next()) { //TODO fixed this line...
+ //spigotdatabase.disconnectFromDatabase();
+ return true;
+ } else {
+ //spigotdatabase.disconnectFromDatabase();
+ return false;
+ }
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ return false;
+ }
+
+ }
+
+ public boolean hasNickname(UUID uuid) {
+
+ if (!connected) {
+ System.err.println("NOT CONNECTED TO DB?!?!?!?"); //TODO?
+ return false;
+ }
+
+ try {
+ synchronized (spigotdatabase) {
+ spigotdatabase.connectToDatabase();
+
+ ResultSet results = spigotdatabase.query("SELECT id FROM nick_data WHERE id = '" + uuid.toString() + "';");
+ if (results.next()) { //TODO fixed this line...
+ //spigotdatabase.disconnectFromDatabase();
+ return true;
+ } else {
+ //spigotdatabase.disconnectFromDatabase();
+ return false;
+ }
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ return false;
+ }
+
+ }
+
+ public void registerMigratedPlayer(UUID uuid, String name, String formattedName, String nick, String formattedNick) {
+
+ if (!connected) {
+ System.err.println("NOT CONNECTED TO DB?!?!?!?"); //TODO?
+ return;
+ }
+
+ // TODO remove debug
+ //System.out.println(name + "," + formattedName + "," + (nick == null ? "NULL!!!" : nick) + "," + (formattedNick == null ? "NULL!!!" : formattedNick) );
+
+ boolean setNick = (nick != null);
+
+ // TODO remove debug
+ //System.out.println("SETNICK: " + setNick);
+
+ if (existsUUID(uuid)) {
+
+ synchronized (spigotdatabase) {
+
+ try {
+ spigotdatabase.connectToDatabase();
+ spigotdatabase.update("UPDATE name_data SET f_name = '" + formattedName + "', u_name = '" + name + "' WHERE id = '" + uuid.toString() + "';");
+
+ if (setNick) {
+
+ if (hasNickname(uuid)) {
+ spigotdatabase.update("UPDATE nick_data SET u_nick = '" + nick + "', f_nick = '" + formattedNick + "' WHERE id = '" + uuid.toString() + "';");
+ } else {
+ spigotdatabase.update("INSERT INTO nick_data VALUES ('" + uuid.toString() + "', '" + nick + "', '" + formattedNick + "');");
+ }
+
+ }
+ } catch (SQLException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+
+ }
+
+ } else {
+
+ try {
+ synchronized (spigotdatabase) {
+
+ spigotdatabase.connectToDatabase();
+ spigotdatabase.update("INSERT INTO name_data VALUES ('" + uuid.toString() + "', '" + formattedName + "', '" + name + "');");
+
+ if (setNick) {
+ spigotdatabase.update("INSERT INTO nick_data VALUES ('" + uuid.toString() + "', '" + nick + "', '" + formattedNick + "');");
+ }
+
+ //spigotdatabase.disconnectFromDatabase();
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ }
+
+ }
+
+ }
+
+ @Override
+ public void registerOfflinePlayerByUUID(UUID uuid, String username) {
+
+ if (!connected) {
+ System.err.println("NOT CONNECTED TO DB?!?!?!?"); //TODO?
+ return;
+ }
+
+ if (existsUUID(uuid)) {
+
+ /*
+ * EMPTY : Player does not need registering
+ */
+
+ } else {
+
+ try {
+ synchronized (spigotdatabase) {
+ spigotdatabase.connectToDatabase();
+
+ spigotdatabase.update("INSERT INTO name_data VALUES ('" + uuid.toString() + "', '" + username + "', '" + username.toLowerCase() + "');");
+
+ //spigotdatabase.disconnectFromDatabase();
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ }
+
+ }
+
+ }
+
+ @Override
+ public void unregisterPlayer(Player player) {
+
+ online.remove(player.getUniqueId());
+ Bukkit.getLogger().info("[-] " + player.getName() + " has left this server.");
+
+ }
+
+ @Override
+ public void setNickname(UUID uuid, String nickname) {
+
+ if (!connected) {
+ System.err.println("NOT CONNECTED TO DB?!?!?!?"); //TODO?
+ return;
+ }
+
+ if (!existsUUID(uuid)) {
+ return;
+ }
+
+ String unformattedNickname = stripAllFormattingCodes(nickname.toLowerCase());
+
+ if (otherPlayerHasNickname(unformattedNickname, uuid)) {
+ return;
+ }
+
+ try {
+ synchronized (spigotdatabase) {
+
+ if (hasNickname(uuid)) {
+ spigotdatabase.connectToDatabase();
+ spigotdatabase.update("UPDATE nick_data SET u_nick = '" + unformattedNickname + "', f_nick = '" + nickname + "' WHERE id = '" + uuid.toString() + "';");
+ } else {
+ spigotdatabase.connectToDatabase();
+ spigotdatabase.update("INSERT INTO nick_data VALUES ('" + uuid.toString() + "', '" + unformattedNickname + "', '" + nickname + "');");
+ }
+
+ //spigotdatabase.disconnectFromDatabase();
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ }
+
+ }
+
+ @Override
+ public boolean existsPlayer(String username) {
+
+ if (!connected) {
+ System.err.println("NOT CONNECTED TO DB?!?!?!?"); //TODO?
+ return false;
+ }
+
+ try {
+ synchronized (spigotdatabase) {
+ spigotdatabase.connectToDatabase();
+
+ ResultSet results = spigotdatabase.query("SELECT u_name FROM name_data WHERE u_name = '" + username.toLowerCase() + "';");
+ if (results.next()) {
+ //spigotdatabase.disconnectFromDatabase();
+ return true;
+ } else {
+ //spigotdatabase.disconnectFromDatabase();
+ return false;
+ }
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ return false;
+ }
+
+ }
+
+ @Override
+ public boolean existsNickname(String nickname) {
+
+ if (!connected) {
+ System.err.println("NOT CONNECTED TO DB?!?!?!?"); //TODO?
+ return false;
+ }
+
+ try {
+ synchronized (spigotdatabase) {
+ spigotdatabase.connectToDatabase();
+
+ ResultSet results = spigotdatabase.query("SELECT u_nick FROM nick_data WHERE u_nick = '" + stripAllFormattingCodes(nickname.toLowerCase()) + "';");
+ if (results.next()) {
+ //spigotdatabase.disconnectFromDatabase();
+ return true;
+ } else {
+ //spigotdatabase.disconnectFromDatabase();
+ return false;
+ }
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ return false;
+ }
+
+ }
+
+ public boolean otherPlayerHasNickname(String nickname, UUID uuid) {
+
+ if (!connected) {
+ System.err.println("NOT CONNECTED TO DB?!?!?!?"); //TODO?
+ return false;
+ }
+
+ try {
+ synchronized (spigotdatabase) {
+ spigotdatabase.connectToDatabase();
+
+ ResultSet results = spigotdatabase.query("SELECT id, u_nick FROM nick_data WHERE u_nick = '" + stripAllFormattingCodes(nickname.toLowerCase()) + "';");
+ if (results.next()) {
+ if (results.getString("id").equals(uuid.toString())) {
+ //spigotdatabase.disconnectFromDatabase();
+ return false;
+ } else {
+ //spigotdatabase.disconnectFromDatabase();
+ return true;
+ }
+ } else {
+ //spigotdatabase.disconnectFromDatabase();
+ return false;
+ }
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ return false;
+ }
+
+ }
+
+ @Override
+ public Optional> getPartialNicknameMatches(String nickname) {
+
+ if (!connected) {
+ System.err.println("NOT CONNECTED TO DB?!?!?!?"); //TODO?
+ return Optional.empty();
+ }
+
+ try {
+ synchronized (spigotdatabase) {
+ spigotdatabase.connectToDatabase();
+
+ ResultSet results = spigotdatabase.query("SELECT id FROM nick_data WHERE (u_nick LIKE '%" + stripAllFormattingCodes(nickname.toLowerCase()) + "%');");
+ if (results.next()) {
+ Set uuids = new HashSet();
+ uuids.add(UUID.fromString(results.getString("id")));
+
+ while (results.next()) {
+ uuids.add(UUID.fromString(results.getString("id")));
+ }
+
+ //spigotdatabase.disconnectFromDatabase();
+ return Optional.of(uuids);
+ } else {
+ //spigotdatabase.disconnectFromDatabase();
+ return Optional.empty();
+ }
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ return Optional.empty();
+ }
+
+ }
+
+ @Override
+ public Optional> getPartialNameMatches(String name) {
+
+ if (!connected) {
+ System.err.println("NOT CONNECTED TO DB?!?!?!?"); //TODO?
+ return Optional.empty();
+ }
+
+ try {
+ synchronized (spigotdatabase) {
+ spigotdatabase.connectToDatabase();
+
+ ResultSet results = spigotdatabase.query("SELECT id, f_name FROM name_data WHERE (u_name LIKE '%" + name.toLowerCase() + "%');");
+ if (results.next()) {
+ Set uuids = new HashSet();
+ uuids.add(UUID.fromString(results.getString("id")));
+
+ while (results.next()) {
+ uuids.add(UUID.fromString(results.getString("id")));
+ }
+
+ //spigotdatabase.disconnectFromDatabase();
+ return Optional.of(uuids);
+ } else {
+ //spigotdatabase.disconnectFromDatabase();
+ return Optional.empty();
+ }
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ return Optional.empty();
+ }
+
+ }
+
+ @Override
+ public void removeNickname(UUID uuid) {
+
+ if (!connected) {
+ System.err.println("NOT CONNECTED TO DB?!?!?!?"); //TODO?
+ return;
+ }
+
+ if (!existsUUID(uuid)) {
+ return;
+ }
+
+ try {
+
+ synchronized (spigotdatabase) {
+
+ if (!hasNickname(uuid)) {
+ return;
+ }
+
+ spigotdatabase.connectToDatabase();
+
+ spigotdatabase.update("DELETE FROM nick_data WHERE id = '" + uuid.toString() + "';");
+
+ //spigotdatabase.disconnectFromDatabase();
+ }
+
+ } catch (SQLException e) {
+ e.printStackTrace();
+ }
+
+ }
+
+}
diff --git a/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/SpigotCommunicationManager.java b/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/SpigotCommunicationManager.java
index 88de0ac4..44210aa8 100644
--- a/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/SpigotCommunicationManager.java
+++ b/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/SpigotCommunicationManager.java
@@ -26,6 +26,37 @@ private SpigotCommunicationManager() {
/* Empty */
}
+ public void sendProxyExecuteMessage(String command) {
+
+ ByteArrayOutputStream stream = new ByteArrayOutputStream();
+ DataOutputStream out = new DataOutputStream(stream);
+
+ try {
+ out.writeUTF(command);
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+
+ ((PluginMessageRecipient)Bukkit.getServer().getOnlinePlayers().toArray()[0]).sendPluginMessage(Bukkit.getPluginManager().getPlugin(MultiChatSpigot.pluginName), "multichat:pxe", stream.toByteArray());
+
+ }
+
+ public void sendProxyExecutePlayerMessage(String command, String player) {
+
+ ByteArrayOutputStream stream = new ByteArrayOutputStream();
+ DataOutputStream out = new DataOutputStream(stream);
+
+ try {
+ out.writeUTF(command);
+ out.writeUTF(player);
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+
+ ((PluginMessageRecipient)Bukkit.getServer().getOnlinePlayers().toArray()[0]).sendPluginMessage(Bukkit.getPluginManager().getPlugin(MultiChatSpigot.pluginName), "multichat:ppxe", stream.toByteArray());
+
+ }
+
public void sendPluginChannelMessage(String channel, UUID uuid, String message) {
ByteArrayOutputStream stream = new ByteArrayOutputStream();
diff --git a/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/commands/CommandHandler.java b/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/commands/CommandHandler.java
index 9bd33a02..ed926179 100644
--- a/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/commands/CommandHandler.java
+++ b/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/commands/CommandHandler.java
@@ -1,5 +1,11 @@
package xyz.olivermartin.multichat.spigotbridge.commands;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.util.Map;
+import java.util.Map.Entry;
import java.util.Optional;
import java.util.Set;
import java.util.UUID;
@@ -14,9 +20,12 @@
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
+import xyz.olivermartin.multichat.spigotbridge.FileNameManager;
import xyz.olivermartin.multichat.spigotbridge.MetaManager;
import xyz.olivermartin.multichat.spigotbridge.MultiChatSpigot;
import xyz.olivermartin.multichat.spigotbridge.NameManager;
+import xyz.olivermartin.multichat.spigotbridge.SQLNameManager;
+import xyz.olivermartin.multichat.spigotbridge.SpigotCommunicationManager;
import xyz.olivermartin.multichat.spigotbridge.SpigotConfigManager;
public class CommandHandler implements CommandExecutor {
@@ -87,6 +96,11 @@ public boolean onCommand(CommandSender commandSender, Command cmd, String label,
MultiChatSpigot.nicknameLengthIncludeFormatting = config.getBoolean("nickname_length_limit_formatting");
}
+ if (config.contains("nickname_length_min")) {
+
+ MultiChatSpigot.nicknameMinLength = config.getInt("nickname_length_min");
+
+ }
}
commandSender.sendMessage(ChatColor.GREEN + "The plugin has been reloaded!");
@@ -98,11 +112,163 @@ public boolean onCommand(CommandSender commandSender, Command cmd, String label,
return true;
}
+ } else if (args[0].equalsIgnoreCase("migratetosql")) {
+
+ if (commandSender instanceof Player) {
+
+ commandSender.sendMessage(ChatColor.DARK_RED + "This command can only be executed from the server console for security reasons!");
+ return true;
+
+ } else {
+
+ if (! (NameManager.getInstance() instanceof SQLNameManager)) {
+ commandSender.sendMessage(ChatColor.DARK_RED + "This command can only be used in SQL mode!");
+ return true;
+ }
+
+ File f = new File(MultiChatSpigot.configDir, MultiChatSpigot.nameDataFile);
+ FileNameManager fnm = new FileNameManager();
+
+ if ((f.exists()) && (!f.isDirectory())) {
+
+ commandSender.sendMessage(ChatColor.GREEN + "Starting load of nickname file data...");
+
+ File file = new File(MultiChatSpigot.configDir, MultiChatSpigot.nameDataFile);
+ FileInputStream saveFile;
+ try {
+ saveFile = new FileInputStream(file);
+ fnm.loadNicknameData(saveFile);
+ commandSender.sendMessage(ChatColor.GREEN + "Successfully loaded nickname data...");
+
+ Map mapUUIDName = fnm.getMapUUIDName();
+ Map mapUUIDNick = fnm.getMapUUIDNick();
+ Map mapNameFormatted = fnm.getMapNameFormatted();
+ Map mapNickFormatted = fnm.getMapNickFormatted();
+
+ commandSender.sendMessage(ChatColor.GREEN + "Starting migration");
+
+ int count = 0;
+ int max = mapUUIDName.size();
+ int checkcount = 25;
+ int checkpoint = checkcount/100*max;
+
+ for (Entry entry : mapUUIDName.entrySet()) {
+
+ count++;
+ if (count > checkpoint) {
+ commandSender.sendMessage(ChatColor.GREEN + "Completed " + checkcount + "% of migration...");
+ checkcount += 25;
+ checkpoint = checkcount/100*max;
+ }
+
+ UUID uuid = entry.getKey();
+ String name = entry.getValue();
+ String formattedName = mapNameFormatted.get(name);
+ String nick;
+ String formattedNick;
+ if (mapUUIDNick.containsKey(uuid)) {
+ nick = mapUUIDNick.get(uuid);
+ formattedNick = mapNickFormatted.get(nick);
+ if (formattedNick.equals(formattedName)) {
+ nick = null;
+ formattedNick = null;
+ }
+ } else {
+ nick = null;
+ formattedNick = null;
+ }
+
+
+
+ ((SQLNameManager)NameManager.getInstance()).registerMigratedPlayer(uuid, name, formattedName, nick, formattedNick);
+
+ }
+
+ commandSender.sendMessage(ChatColor.GREEN + "Successfully migrated: " + max + " records");
+
+ commandSender.sendMessage(ChatColor.GREEN + "Saving nickname data file...");
+
+ FileOutputStream saveFile2 = new FileOutputStream(file);
+ fnm.saveNicknameData(saveFile2);
+
+ } catch (FileNotFoundException e) {
+ commandSender.sendMessage(ChatColor.DARK_RED + "[ERROR] Could not load nickname data!");
+ e.printStackTrace();
+ }
+
+ }
+
+ return true;
+
+ }
+
} else {
// Show usage
return false;
}
+ } else if (cmd.getName().equalsIgnoreCase("pxe") || cmd.getName().equalsIgnoreCase("pexecute")) {
+
+
+ /* PROXY EXECUTE */
+
+ // Show usage
+ if (args.length < 1) {
+
+ return false;
+
+ } else {
+
+ boolean playerFlag = false;
+ String player = ".*";
+
+ // Handle flags
+ int index = 0;
+
+ while (index < args.length) {
+
+ if (args[index].equalsIgnoreCase("-p")) {
+ if (index+1 < args.length) {
+ playerFlag = true;
+ player = args[index+1];
+ }
+ } else {
+ break;
+ }
+
+ index = index+2;
+
+ }
+
+ if (index >= args.length) {
+ return false; // Show usage
+ }
+
+ String message = "";
+ for (String arg : args) {
+ if (index > 0) {
+ index--;
+ } else {
+ message = message + arg + " ";
+ }
+ }
+
+ if (playerFlag) {
+
+ SpigotCommunicationManager.getInstance().sendProxyExecutePlayerMessage(message, player);
+
+ } else {
+
+ SpigotCommunicationManager.getInstance().sendProxyExecuteMessage(message);
+
+ }
+
+ commandSender.sendMessage(ChatColor.GREEN + "SENT COMMAND TO PROXY SERVER");
+
+ return true;
+
+ }
+
}
if (cmd.getName().equalsIgnoreCase("nick")) {
@@ -150,19 +316,28 @@ public boolean onCommand(CommandSender commandSender, Command cmd, String label,
if (MultiChatSpigot.nicknameLengthIncludeFormatting) {
// Include formatting codes in the nickname length
if (args[0].length() > MultiChatSpigot.nicknameMaxLength && !sender.hasPermission("multichatspigot.nick.anylength")) {
-
sender.sendMessage(ChatColor.DARK_RED + "Sorry your nickname is too long, max " + MultiChatSpigot.nicknameMaxLength + " characters! (Including format codes)");
return true;
-
+ }
+ if (args[0].length() < MultiChatSpigot.nicknameMinLength && !sender.hasPermission("multichatspigot.nick.anylength")) {
+ sender.sendMessage(ChatColor.DARK_RED + "Sorry your nickname is too short, min " + MultiChatSpigot.nicknameMinLength + " characters! (Including format codes)");
+ return true;
}
} else {
// Do not include formatting codes in the nickname length
if (NameManager.getInstance().stripAllFormattingCodes(args[0]).length() > MultiChatSpigot.nicknameMaxLength && !sender.hasPermission("multichatspigot.nick.anylength")) {
-
sender.sendMessage(ChatColor.DARK_RED + "Sorry your nickname is too long, max " + MultiChatSpigot.nicknameMaxLength + " characters! (Excluding format codes)");
return true;
-
}
+ if (NameManager.getInstance().stripAllFormattingCodes(args[0]).length() < MultiChatSpigot.nicknameMinLength && !sender.hasPermission("multichatspigot.nick.anylength")) {
+ sender.sendMessage(ChatColor.DARK_RED + "Sorry your nickname is too short, min " + MultiChatSpigot.nicknameMinLength + " characters! (Excluding format codes)");
+ return true;
+ }
+ }
+
+ if (NameManager.getInstance().stripAllFormattingCodes(args[0]).length() < 1) {
+ sender.sendMessage(ChatColor.DARK_RED + "Sorry your nickname cannot be empty!");
+ return true;
}
String targetNickname = NameManager.getInstance().stripAllFormattingCodes(NameManager.getInstance().getCurrentName(targetUUID));
@@ -187,7 +362,7 @@ public boolean onCommand(CommandSender commandSender, Command cmd, String label,
if (NameManager.getInstance().stripAllFormattingCodes(args[0]).matches(bl)) blacklisted = true;
}
- if (blacklisted) {
+ if (blacklisted && !sender.hasPermission("multichatspigot.nick.blacklist")) {
sender.sendMessage(ChatColor.DARK_RED + "Sorry, this name is not allowed!");
return true;
@@ -245,32 +420,41 @@ public boolean onCommand(CommandSender commandSender, Command cmd, String label,
if (MultiChatSpigot.nicknameLengthIncludeFormatting) {
// Include formatting codes in the nickname length
if (args[1].length() > MultiChatSpigot.nicknameMaxLength && !sender.hasPermission("multichatspigot.nick.anylength")) {
-
sender.sendMessage(ChatColor.DARK_RED + "Sorry your nickname is too long, max " + MultiChatSpigot.nicknameMaxLength + " characters! (Including format codes)");
return true;
-
+ }
+ if (args[1].length() < MultiChatSpigot.nicknameMinLength && !sender.hasPermission("multichatspigot.nick.anylength")) {
+ sender.sendMessage(ChatColor.DARK_RED + "Sorry your nickname is too short, min " + MultiChatSpigot.nicknameMinLength + " characters! (Including format codes)");
+ return true;
}
} else {
// Do not include formatting codes in the nickname length
if (NameManager.getInstance().stripAllFormattingCodes(args[1]).length() > MultiChatSpigot.nicknameMaxLength && !sender.hasPermission("multichatspigot.nick.anylength")) {
-
sender.sendMessage(ChatColor.DARK_RED + "Sorry your nickname is too long, max " + MultiChatSpigot.nicknameMaxLength + " characters! (Excluding format codes)");
return true;
-
+ }
+ if (NameManager.getInstance().stripAllFormattingCodes(args[1]).length() < MultiChatSpigot.nicknameMinLength && !sender.hasPermission("multichatspigot.nick.anylength")) {
+ sender.sendMessage(ChatColor.DARK_RED + "Sorry your nickname is too short, min " + MultiChatSpigot.nicknameMinLength + " characters! (Excluding format codes)");
+ return true;
}
}
+ if (NameManager.getInstance().stripAllFormattingCodes(args[1]).length() < 1) {
+ sender.sendMessage(ChatColor.DARK_RED + "Sorry your nickname cannot be empty!");
+ return true;
+ }
+
String targetNickname = NameManager.getInstance().stripAllFormattingCodes(NameManager.getInstance().getCurrentName(targetUUID));
String targetName = NameManager.getInstance().getName(targetUUID);
- if (NameManager.getInstance().existsNickname(args[1]) && !targetNickname.equalsIgnoreCase(NameManager.getInstance().stripAllFormattingCodes(args[0])) ) { //&& !sender.hasPermission("multichatspigot.nick.duplicate")) {
+ if (NameManager.getInstance().existsNickname(args[1]) && !targetNickname.equalsIgnoreCase(NameManager.getInstance().stripAllFormattingCodes(args[1])) ) { //&& !sender.hasPermission("multichatspigot.nick.duplicate")) {
sender.sendMessage(ChatColor.DARK_RED + "Sorry, this nickname is already in use!");
return true;
}
- if (NameManager.getInstance().existsPlayer(args[1]) && !targetName.equalsIgnoreCase(NameManager.getInstance().stripAllFormattingCodes(args[0])) && !sender.hasPermission("multichatspigot.nick.impersonate")) {
+ if (NameManager.getInstance().existsPlayer(args[1]) && !targetName.equalsIgnoreCase(NameManager.getInstance().stripAllFormattingCodes(args[1])) && !sender.hasPermission("multichatspigot.nick.impersonate")) {
sender.sendMessage(ChatColor.DARK_RED + "Sorry, a player already exists with this name!");
return true;
@@ -282,7 +466,7 @@ public boolean onCommand(CommandSender commandSender, Command cmd, String label,
if (NameManager.getInstance().stripAllFormattingCodes(args[1]).matches(bl)) blacklisted = true;
}
- if (blacklisted) {
+ if (blacklisted && !sender.hasPermission("multichatspigot.nick.blacklist")) {
sender.sendMessage(ChatColor.DARK_RED + "Sorry, this name is not allowed!");
return true;
@@ -438,7 +622,7 @@ public boolean onCommand(CommandSender commandSender, Command cmd, String label,
}
- }
+ }
return false;
}
diff --git a/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/database/DatabaseManager.java b/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/database/DatabaseManager.java
deleted file mode 100644
index 31de05a7..00000000
--- a/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/database/DatabaseManager.java
+++ /dev/null
@@ -1,99 +0,0 @@
-package xyz.olivermartin.multichat.spigotbridge.database;
-
-import java.io.File;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Optional;
-
-/*
- * DROP TABLE IF EXISTS nicknames;
-
-CREATE TABLE nicknames(id VARCHAR(128) PRIMARY KEY, u_nick VARCHAR(255), f_nick VARCHAR(255));
-
-INSERT INTO nicknames VALUES ('255-444-2221--11-11', 'revilo', '&4Revilo');
-
-SELECT * FROM nicknames;
- */
-
-public class DatabaseManager {
-
- private static DatabaseManager instance;
-
- public static DatabaseManager getInstance() {
- return instance;
- }
-
- static {
- instance = new DatabaseManager();
- }
-
- /* END STATIC */
-
- private File databasePath;
- private DatabaseMode databaseMode = DatabaseMode.SQLite;
-
- private Map databases;
-
- private DatabaseManager() {
- databases = new HashMap();
- }
-
- ////////////
-
- public static void main(String args[]) {
- DatabaseManager.getInstance().setPath(new File("C:\\multichat\\db\\"));
- DatabaseManager.getInstance().createDatabase("testing.db");
- }
-
- ////////////
-
- public void setPath(File path) {
- this.databasePath = path;
- }
-
- public GenericDatabase createDatabase(String name) {
- return createDatabase(name, name);
- }
-
- public boolean isReady() {
- return databasePath != null;
- }
-
- /**
- * Generic class to create a sqlite database
- */
- public GenericDatabase createDatabase(String databaseName, String fileName) {
-
- if (!isReady()) throw new RuntimeException("MultiChat Database Manager Not Ready!");
-
- if (!databasePath.exists()) {
- databasePath.mkdirs();
- }
-
- switch (databaseMode) {
- case SQLite:
- default:
- // TODO check doesnt already exist
- databases.put(databaseName.toLowerCase(), new SQLiteDatabase(databasePath, fileName));
- return databases.get(databaseName.toLowerCase());
- }
-
- }
-
- public Optional getDatabase(String databaseName) {
- if (databases.containsKey(databaseName.toLowerCase())) {
- return Optional.of(databases.get(databaseName.toLowerCase()));
- } else {
- return Optional.empty();
- }
- }
-
- public void removeDatabase(String databaseName) {
- if (databases.containsKey(databaseName.toLowerCase())) {
- GenericDatabase gdb = databases.get(databaseName.toLowerCase());
- gdb.disconnectFromDatabase();
- databases.remove(databaseName.toLowerCase());
- }
- }
-
-}
diff --git a/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/database/DatabaseMode.java b/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/database/DatabaseMode.java
deleted file mode 100644
index 1696d475..00000000
--- a/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/database/DatabaseMode.java
+++ /dev/null
@@ -1,7 +0,0 @@
-package xyz.olivermartin.multichat.spigotbridge.database;
-
-public enum DatabaseMode {
-
- SQLite
-
-}
diff --git a/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/database/GenericDatabase.java b/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/database/GenericDatabase.java
deleted file mode 100644
index 2d31261d..00000000
--- a/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/database/GenericDatabase.java
+++ /dev/null
@@ -1,36 +0,0 @@
-package xyz.olivermartin.multichat.spigotbridge.database;
-
-public abstract class GenericDatabase {
-
- protected String url;
- private boolean ready;
-
- public GenericDatabase(String url) {
- this.url = url;
- ready = setupDatabase(url);
- }
-
- public String getURL() {
- return this.url;
- }
-
- public boolean isReady() {
- return this.ready;
- }
-
- protected abstract boolean setupDatabase(String url);
-
- protected abstract void disconnect();
-
- protected abstract boolean connect();
-
- public void connectToDatabase() {
- this.ready = connect();
- }
-
- public void disconnectFromDatabase() {
- disconnect();
- this.ready = false;
- }
-
-}
diff --git a/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/database/SQLiteDatabase.java b/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/database/SQLiteDatabase.java
deleted file mode 100644
index 4eeff0a3..00000000
--- a/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/database/SQLiteDatabase.java
+++ /dev/null
@@ -1,78 +0,0 @@
-package xyz.olivermartin.multichat.spigotbridge.database;
-
-import java.io.File;
-import java.sql.Connection;
-import java.sql.DatabaseMetaData;
-import java.sql.DriverManager;
-import java.sql.SQLException;
-
-public class SQLiteDatabase extends GenericDatabase {
-
- private static final String URL_PREFIX = "jdbc:sqlite:";
- private Connection conn;
-
- public SQLiteDatabase(File path, String filename) {
- super(URL_PREFIX + path + File.separator + filename);
- }
-
- protected boolean setupDatabase(String url) {
-
- try (Connection conn = DriverManager.getConnection(url)) {
-
- if (conn != null) {
- DatabaseMetaData meta = conn.getMetaData();
- System.out.println("The driver name is " + meta.getDriverName());
- System.out.println("A new database has been created.");
-
- this.conn = conn;
-
- // Database successfully created
- return true;
- }
-
- } catch (SQLException e) {
- System.out.println(e.getMessage());
- }
-
- // Database not successfully created
- return false;
-
- }
-
- @Override
- protected void disconnect() {
-
- if (conn != null) {
- try {
- if (!conn.isClosed()) {
- conn.close();
- }
- } catch (SQLException e) {
- e.printStackTrace();
- }
- }
-
- }
-
- @Override
- protected boolean connect() {
-
- if (conn == null) {
-
- return setupDatabase(url);
-
- } else {
- try {
- if (conn.isClosed()) {
- return setupDatabase(url);
- }
- } catch (SQLException e) {
- return false;
- }
- }
-
- // Already connected
- return true;
- }
-
-}
diff --git a/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/listeners/ChatListenerHighest.java b/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/listeners/ChatListenerHighest.java
index 33e40d5d..6eccf554 100644
--- a/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/listeners/ChatListenerHighest.java
+++ b/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/listeners/ChatListenerHighest.java
@@ -57,6 +57,15 @@ public void onChat(final AsyncPlayerChatEvent event) {
String channelName = MultiChatSpigot.playerChannels.get(event.getPlayer());
+ // HACK for /local and /global
+
+ if (MultiChatSpigot.chatQueues.containsKey(event.getPlayer().getName().toLowerCase())) {
+ String tempChannel = MultiChatSpigot.chatQueues.get(event.getPlayer().getName().toLowerCase()).peek();
+ channelName = tempChannel.startsWith("!SINGLE L MESSAGE!") ? "local" : "global";
+ }
+
+ // END HACK
+
if (MultiChatSpigot.channelObjects.containsKey(channelName)) {
PseudoChannel channelObject = MultiChatSpigot.channelObjects.get(channelName);
@@ -96,10 +105,20 @@ public void onChat(final AsyncPlayerChatEvent event) {
}
if (MultiChatSpigot.playerChannels.containsKey(event.getPlayer())) {
+
+ if (!MultiChatSpigot.globalChatServer) {
+ return;
+ }
+
+ if (MultiChatSpigot.chatQueues.containsKey(event.getPlayer().getName().toLowerCase())) {
+ // Hack for /global /local direct messaging...
+ String tempChannel = MultiChatSpigot.chatQueues.get(event.getPlayer().getName().toLowerCase()).peek();
+ if(tempChannel.startsWith("!SINGLE L MESSAGE!")) {
+ return;
+ }
+ } else if (MultiChatSpigot.playerChannels.get(event.getPlayer()).equals("local") || (!MultiChatSpigot.globalChatServer)) {
- if (MultiChatSpigot.playerChannels.get(event.getPlayer()).equals("local")) {
-
- // If its a local chat message then we dont need to do anything else!
+ // If its a local chat message (or we can't use global chat here) then we dont need to do anything else!
return;
}
diff --git a/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/listeners/ChatListenerLowest.java b/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/listeners/ChatListenerLowest.java
index 8d0b38d3..2cebadfe 100644
--- a/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/listeners/ChatListenerLowest.java
+++ b/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/listeners/ChatListenerLowest.java
@@ -29,8 +29,18 @@ public void onChat2(final AsyncPlayerChatEvent event) {
channel = "global";
}
+ if (MultiChatSpigot.chatQueues.containsKey(event.getPlayer().getName().toLowerCase())) {
+ // Hack for /global /local direct messaging...
+ String tempChannel = MultiChatSpigot.chatQueues.get(event.getPlayer().getName().toLowerCase()).peek();
+ if(tempChannel.startsWith("!SINGLE L MESSAGE!")) {
+ channel = "local";
+ } else {
+ channel = "global";
+ }
+ }
+
- if (channel.equals("local")) {
+ if (channel.equals("local") || (!MultiChatSpigot.globalChatServer)) {
// Local chat
@@ -80,10 +90,11 @@ public void onChat2(final AsyncPlayerChatEvent event) {
format = format.replace("!!!1!!!", "%1$s");
format = format.replace("!!!2!!!", "%2$s");
- if (channel.equals("local")) {
- // If we are a global chat server, then we want to set the format!
- if (MultiChatSpigot.globalChatServer) event.setFormat(ChatColor.translateAlternateColorCodes('&', format));
+ if (channel.equals("local") || (!MultiChatSpigot.globalChatServer)) {
+ // TRY TO FIX ISSUE WITH MULTICHAT NOT FORMATTING LOCAL MESSAGES IF NOT IN GLOBAL MODE if (MultiChatSpigot.globalChatServer) event.setFormat(ChatColor.translateAlternateColorCodes('&', format));
+ event.setFormat(ChatColor.translateAlternateColorCodes('&', format));
} else {
+ // If we are a global chat server, then we want to set the format!
if (MultiChatSpigot.globalChatServer) event.setFormat(ChatColor.translateAlternateColorCodes('&', format));
}
}
diff --git a/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/listeners/ChatListenerMonitor.java b/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/listeners/ChatListenerMonitor.java
index 3b879264..14e3c71c 100644
--- a/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/listeners/ChatListenerMonitor.java
+++ b/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/listeners/ChatListenerMonitor.java
@@ -14,13 +14,40 @@ public class ChatListenerMonitor implements Listener {
@EventHandler(priority=EventPriority.MONITOR)
public void onChat(final AsyncPlayerChatEvent event) {
+ String queueValue = "";
+
+ if (MultiChatSpigot.chatQueues.containsKey(event.getPlayer().getName().toLowerCase())) {
+ // Hack for /global /local direct messaging...
+ String tempChannel = MultiChatSpigot.chatQueues.get(event.getPlayer().getName().toLowerCase()).poll();
+
+ if (MultiChatSpigot.chatQueues.get(event.getPlayer().getName().toLowerCase()).size() < 1) {
+ MultiChatSpigot.chatQueues.remove(event.getPlayer().getName().toLowerCase());
+ }
+
+ if(tempChannel.startsWith("!SINGLE L MESSAGE!")) {
+ queueValue = "local";
+ } else {
+ queueValue = "global";
+ }
+ }
+
// IF ITS ALREADY CANCELLED WE CAN IGNORE IT
if (event.isCancelled()) return;
// IF ITS LOCAL CHAT WE CAN IGNORE IT
if (MultiChatSpigot.playerChannels.containsKey(event.getPlayer())) {
- if (MultiChatSpigot.playerChannels.get(event.getPlayer()).equals("local")) {
+
+ if (!MultiChatSpigot.globalChatServer) {
+ return;
+ }
+
+ if (!queueValue.equals("")) {
+ // Hack for /global /local direct messaging...
+ if (queueValue.equalsIgnoreCase("local")) {
+ return;
+ }
+ } else if (MultiChatSpigot.playerChannels.get(event.getPlayer()).equals("local") || (!MultiChatSpigot.globalChatServer)) {
return;
}
}
diff --git a/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/listeners/MultiChatPluginMessageListener.java b/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/listeners/MultiChatPluginMessageListener.java
index b097b3d2..40655327 100644
--- a/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/listeners/MultiChatPluginMessageListener.java
+++ b/multichat/src/main/java/xyz/olivermartin/multichat/spigotbridge/listeners/MultiChatPluginMessageListener.java
@@ -4,8 +4,10 @@
import java.io.DataInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
+import java.util.LinkedList;
import java.util.List;
import java.util.Map;
+import java.util.Queue;
import java.util.Set;
import java.util.UUID;
@@ -114,6 +116,40 @@ public void onPluginMessageReceived(String channel, Player player, byte[] bytes)
String playerRegex = in.readUTF();
String command = in.readUTF();
+ /* THIS BIT NOW IS A BIT OF A HACK! */
+
+ /*
+ * To implement sending single messages to global or local chat channels, we do a nice hack...
+ * We send a "command" of local or global chat...
+ * Then we deal with it here and add to the "CHAT QUEUE" in the MultiChatSpigot class
+ * And then we send the chat message as if it were normal, but it will check the CHAT QUEUE to deal with it...
+ */
+
+ if (command.startsWith("!SINGLE L MESSAGE!") || command.startsWith("!SINGLE G MESSAGE!")) {
+
+ String message = command.substring("!SINGLE X MESSAGE!".length(),command.length());
+
+ if (MultiChatSpigot.chatQueues.containsKey(playerRegex.toLowerCase())) {
+
+ Queue chatQueue = MultiChatSpigot.chatQueues.get(playerRegex.toLowerCase());
+ chatQueue.add(command);
+
+ } else {
+
+ Queue chatQueue = new LinkedList();
+ chatQueue.add(command);
+ MultiChatSpigot.chatQueues.put(playerRegex.toLowerCase(), chatQueue);
+
+ }
+
+ Bukkit.getServer().getPlayer(playerRegex).chat(message);
+
+ return;
+
+ }
+
+ /* END HACK */
+
for (Player p : Bukkit.getServer().getOnlinePlayers()) {
if (p.getName().matches(playerRegex)) {
diff --git a/multichat/src/main/java/xyz/olivermartin/multichat/spongebridge/MultiChatSponge.java b/multichat/src/main/java/xyz/olivermartin/multichat/spongebridge/MultiChatSponge.java
index d67e7e26..c28c8365 100644
--- a/multichat/src/main/java/xyz/olivermartin/multichat/spongebridge/MultiChatSponge.java
+++ b/multichat/src/main/java/xyz/olivermartin/multichat/spongebridge/MultiChatSponge.java
@@ -2,28 +2,26 @@
import java.io.File;
import java.io.IOException;
+import java.nio.file.Path;
+import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import java.util.Map.Entry;
import java.util.Optional;
+import java.util.Queue;
import java.util.Set;
import java.util.UUID;
-import java.util.regex.Pattern;
import org.spongepowered.api.Platform;
import org.spongepowered.api.Sponge;
-import org.spongepowered.api.command.CommandException;
-import org.spongepowered.api.command.CommandResult;
-import org.spongepowered.api.command.CommandSource;
-import org.spongepowered.api.command.args.CommandContext;
import org.spongepowered.api.command.args.GenericArguments;
-import org.spongepowered.api.command.spec.CommandExecutor;
import org.spongepowered.api.command.spec.CommandSpec;
+import org.spongepowered.api.config.ConfigDir;
import org.spongepowered.api.config.DefaultConfig;
import org.spongepowered.api.data.key.Keys;
import org.spongepowered.api.entity.living.player.Player;
-import org.spongepowered.api.entity.living.player.User;
import org.spongepowered.api.event.Listener;
import org.spongepowered.api.event.game.state.GameStartedServerEvent;
import org.spongepowered.api.event.game.state.GameStoppingServerEvent;
@@ -32,7 +30,6 @@
import org.spongepowered.api.network.ChannelRegistrar;
import org.spongepowered.api.plugin.Dependency;
import org.spongepowered.api.plugin.Plugin;
-import org.spongepowered.api.service.user.UserStorageService;
import org.spongepowered.api.text.Text;
import org.spongepowered.api.text.channel.impl.SimpleMutableMessageChannel;
@@ -45,7 +42,14 @@
import ninja.leaping.configurate.hocon.HoconConfigurationLoader;
import ninja.leaping.configurate.loader.ConfigurationLoader;
import ninja.leaping.configurate.objectmapping.ObjectMappingException;
+import xyz.olivermartin.multichat.database.DatabaseManager;
+import xyz.olivermartin.multichat.database.DatabaseMode;
import xyz.olivermartin.multichat.spigotbridge.PseudoChannel;
+import xyz.olivermartin.multichat.spongebridge.commands.MultiChatSpongeCommand;
+import xyz.olivermartin.multichat.spongebridge.commands.SpongeNickCommand;
+import xyz.olivermartin.multichat.spongebridge.commands.SpongeProxyExecuteCommand;
+import xyz.olivermartin.multichat.spongebridge.commands.SpongeRealnameCommand;
+import xyz.olivermartin.multichat.spongebridge.commands.SpongeUsernameCommand;
import xyz.olivermartin.multichat.spongebridge.listeners.BungeeChatListener;
import xyz.olivermartin.multichat.spongebridge.listeners.BungeeCommandListener;
import xyz.olivermartin.multichat.spongebridge.listeners.BungeePlayerCommandListener;
@@ -62,10 +66,12 @@
* @author Oliver Martin (Revilo410)
*
*/
-@Plugin(id = "multichat", name = "MultiChatSponge", version = "1.7.5", dependencies = { @Dependency(id = "placeholderapi", optional = true) })
-public final class MultiChatSponge implements CommandExecutor {
+@Plugin(id = "multichat", name = "MultiChatSponge", version = "1.8", dependencies = { @Dependency(id = "placeholderapi", optional = true) })
+public final class MultiChatSponge {
public static SimpleMutableMessageChannel multichatChannel;
+
+ public static MultiChatSponge instance;
ChannelRegistrar channelRegistrar;
@@ -83,7 +89,10 @@ public final class MultiChatSponge implements CommandExecutor {
static RawDataChannel channelChannel;
static RawDataChannel ignoreChannel;
- public static Map nicknames;
+ static RawDataChannel pexecuteChannel;
+ static RawDataChannel ppexecuteChannel;
+
+ //public static Map nicknames;
public static Map displayNames = new HashMap();
public static boolean setDisplayNameLastVal = false;
@@ -103,22 +112,34 @@ public final class MultiChatSponge implements CommandExecutor {
public static boolean showNicknamePrefix = false;
public static String nicknamePrefix = "~";
public static List nicknameBlacklist = new ArrayList();
+ public static int nicknameMaxLength = 20;
+ public static int nicknameMinLength = 3;
+ public static boolean nicknameLengthIncludeFormatting = false;
+ public static boolean nicknameSQL = false;
public static Map playerChannels = new HashMap();
public static Map channelObjects = new HashMap();
public static Map> ignoreMap = new HashMap>();
public static Map colourMap = new HashMap();
+
+ public static Map> chatQueues = new HashMap>();
@Inject
@DefaultConfig(sharedRoot = true)
private ConfigurationLoader configLoader;
+ @Inject
+ @ConfigDir(sharedRoot = false)
+ private Path privateConfigDir;
+
@SuppressWarnings("serial")
@Listener
public void onServerStart(GameStartedServerEvent event) {
// DEBUG MODE
- //DebugManager.setDebug(true);
+ //DebugManager.setDebug(true);//TODO
+
+ instance = this;
SpongeConfigManager.getInstance().registerHandler("multichatsponge.yml");
ConfigurationNode config = SpongeConfigManager.getInstance().getHandler("multichatsponge.yml").getConfig();
@@ -131,50 +152,321 @@ public void onServerStart(GameStartedServerEvent event) {
showNicknamePrefix = config.getNode("show_nickname_prefix").getBoolean();
nicknamePrefix = config.getNode("nickname_prefix").getString();
nicknameBlacklist = config.getNode("nickname_blacklist").getList(value -> value.toString());
+ if (!config.getNode("nickname_length_limit").isVirtual()) {
+ nicknameMaxLength = config.getNode("nickname_length_limit").getInt();
+ nicknameLengthIncludeFormatting = config.getNode("nickname_length_limit_formatting").getBoolean();
+ }
+
+ if (!config.getNode("nickname_length_min").isVirtual()) {
+
+ nicknameMinLength = config.getNode("nickname_length_min").getInt();
+
+ }
+
+
+ // SQL
+
+ if (!config.getNode("nickname_sql").isVirtual()) {
+
+ nicknameSQL = config.getNode("nickname_sql").getBoolean();
+
+ if (nicknameSQL) {
+
+ if (config.getNode("mysql").getBoolean()) {
+
+ DatabaseManager.getInstance().setMode(DatabaseMode.MySQL);
+
+ DatabaseManager.getInstance().setURLMySQL(config.getNode("mysql_url").getString());
+ DatabaseManager.getInstance().setUsernameMySQL(config.getNode("mysql_user").getString());
+ DatabaseManager.getInstance().setPasswordMySQL(config.getNode("mysql_pass").getString());
+
+ try {
+
+ if (!config.getNode("mysql_database").isVirtual()) {
+ DatabaseManager.getInstance().createDatabase("multichatsponge.db", config.getNode("mysql_database").getString());
+ } else {
+ DatabaseManager.getInstance().createDatabase("multichatsponge.db", "multichatsponge");
+ }
+
+ DatabaseManager.getInstance().getDatabase("multichatsponge.db").get().connectToDatabase();
+ DatabaseManager.getInstance().getDatabase("multichatsponge.db").get().update("CREATE TABLE IF NOT EXISTS name_data(id VARCHAR(128), f_name VARCHAR(255), u_name VARCHAR(255), PRIMARY KEY (id));");
+ DatabaseManager.getInstance().getDatabase("multichatsponge.db").get().update("CREATE TABLE IF NOT EXISTS nick_data(id VARCHAR(128), u_nick VARCHAR(255), f_nick VARCHAR(255), PRIMARY KEY (id));");
+ ///DatabaseManager.getInstance().getDatabase("multichatsponge.db").get().disconnectFromDatabase();
+
+ SpongeNameManager.useSQL(nicknameSQL);
+
+ } catch (SQLException e) {
+ nicknameSQL = false;
+ SpongeNameManager.useSQL(false);
+ System.err.println("Could not enable database! Using files...");
+ e.printStackTrace();
+ }
+
+ } else {
+
+ DatabaseManager.getInstance().setMode(DatabaseMode.SQLite);
+
+ File configDir = privateConfigDir.toFile();
+
+ if (!(configDir.exists() && configDir.isDirectory())) {
+ configDir.mkdir();
+ }
+
+ DatabaseManager.getInstance().setPathSQLite(configDir);
+
+ try {
+
+ DatabaseManager.getInstance().createDatabase("multichatsponge.db");
+
+ DatabaseManager.getInstance().getDatabase("multichatsponge.db").get().connectToDatabase();
+ DatabaseManager.getInstance().getDatabase("multichatsponge.db").get().update("CREATE TABLE IF NOT EXISTS name_data(id VARCHAR(128), f_name VARCHAR(255), u_name VARCHAR(255), PRIMARY KEY (id));");
+ DatabaseManager.getInstance().getDatabase("multichatsponge.db").get().update("CREATE TABLE IF NOT EXISTS nick_data(id VARCHAR(128), u_nick VARCHAR(255), f_nick VARCHAR(255), PRIMARY KEY (id));");
+ //DatabaseManager.getInstance().getDatabase("multichatsponge.db").get().disconnectFromDatabase();
+
+ SpongeNameManager.useSQL(nicknameSQL);
+
+ } catch (SQLException e) {
+ nicknameSQL = false;
+ SpongeNameManager.useSQL(false);
+ System.err.println("Could not enable database! Using files...");
+ e.printStackTrace();
+ }
+
+ }
+
+ }
+
+ }
+
+ // /SQL
+
+
}
- configLoader = HoconConfigurationLoader.builder().setFile(new File("nicknames")).build();
- ConfigurationNode rootNode;
+ if (SpongeNameManager.getInstance() instanceof SpongeFileNameManager) {
- try {
+ File f = new File("multichat_namedata");
+ File fLegacy = new File("nicknames");
- rootNode = configLoader.load();
+ if ((f.exists()) && (!f.isDirectory())) {
- try {
+ // New file based storage
+ configLoader = HoconConfigurationLoader.builder().setFile(f).build();
+ ConfigurationNode rootNode;
+
+ Map mapUUIDNick;
+ Map mapNickUUID;
+ Map mapNickFormatted;
+
+ try {
+
+ rootNode = configLoader.load();
+
+ try {
+
+ mapUUIDNick = (Map) rootNode.getNode("mapUUIDNick").getValue(new TypeToken>() { /* EMPTY */ });
+ mapNickUUID = (Map) rootNode.getNode("mapNickUUID").getValue(new TypeToken>() { /* EMPTY */ });
+ mapNickFormatted = (Map) rootNode.getNode("mapNickFormatted").getValue(new TypeToken>() { /* EMPTY */ });
+
+ if (mapUUIDNick == null) {
+ mapUUIDNick = new HashMap();
+ mapNickUUID = new HashMap();
+ mapNickFormatted = new HashMap();
+ System.out.println("[MultiChatSponge] Created new nicknames maps for file storage!");
+ }
- nicknames = (Map) rootNode.getNode("nicknames").getValue(new TypeToken>() { /* EMPTY */ });
+ System.out.println("[MultiChatSponge] Nicknames appeared to load correctly!");
- if (nicknames == null) {
+ } catch (ClassCastException e) {
+
+ mapUUIDNick = new HashMap();
+ mapNickUUID = new HashMap();
+ mapNickFormatted = new HashMap();
+
+ } catch (ObjectMappingException e) {
+
+ mapUUIDNick = new HashMap();
+ mapNickUUID = new HashMap();
+ mapNickFormatted = new HashMap();
+
+ }
+
+ try {
+
+ configLoader.save(rootNode);
+
+ } catch (IOException e) {
+
+ e.printStackTrace();
+
+ }
+
+ } catch (IOException e) {
+
+ e.printStackTrace();
+ mapUUIDNick = new HashMap();
+ mapNickUUID = new HashMap();
+ mapNickFormatted = new HashMap();
+
+ }
+
+ ((SpongeFileNameManager)SpongeNameManager.getInstance()).loadFromFile(mapUUIDNick, mapNickUUID, mapNickFormatted);
+
+ } else if (fLegacy.exists()) {
+
+ // Legacy storage
+ ConfigurationLoader legacyConfigLoader = HoconConfigurationLoader.builder().setFile(new File("nicknames")).build();
+ ConfigurationNode rootNode;
+
+ Map nicknames;
+
+ try {
+
+ rootNode = legacyConfigLoader.load();
+
+ try {
+
+ nicknames = (Map) rootNode.getNode("nicknames").getValue(new TypeToken>() { /* EMPTY */ });
+
+ if (nicknames == null) {
+ nicknames = new HashMap();
+ System.out.println("[MultiChatSponge] Created nicknames map");
+ }
+
+ System.out.println("[MultiChatSponge] Loaded a legacy (PRE-1.8) nicknames file!");
+ System.out.println("[MultiChatSponge] Attempting conversion...");
+
+ } catch (ClassCastException e) {
+
+ nicknames = new HashMap();
+
+ } catch (ObjectMappingException e) {
+
+ nicknames = new HashMap();
+
+ }
+
+ try {
+
+ legacyConfigLoader.save(rootNode);
+
+ } catch (IOException e) {
+
+ e.printStackTrace();
+
+ }
+
+ } catch (IOException e) {
+
+ e.printStackTrace();
nicknames = new HashMap();
- System.out.println("[MultiChatSponge] Created nicknames map");
+
}
- System.out.println("[MultiChatSponge] Nicknames appeared to load correctly!");
+ // Now loaded the legacy nicknames into "nicknames" var
- } catch (ClassCastException e) {
+ for (Entry e : nicknames.entrySet()) {
+ SpongeNameManager.getInstance().setNickname(e.getKey(), e.getValue());
+ }
- nicknames = new HashMap();
+ System.out.println("[MultiChatSponge] Conversion completed.");
+ System.out.println("[MultiChatSponge] Converted " + nicknames.size() + " records!");
- } catch (ObjectMappingException e) {
+ // Attempting to save the new file...
- nicknames = new HashMap();
+ configLoader = HoconConfigurationLoader.builder().setFile(f).build();
+ ConfigurationNode rootNode2;
- }
+ rootNode2 = configLoader.createEmptyNode();
- try {
+ try {
- configLoader.save(rootNode);
+ rootNode2.getNode("mapUUIDNick").setValue(new TypeToken>() {},
+ ((SpongeFileNameManager)SpongeNameManager.getInstance()).getMapUUIDNick());
+ rootNode2.getNode("mapNickUUID").setValue(new TypeToken>() {},
+ ((SpongeFileNameManager)SpongeNameManager.getInstance()).getMapNickUUID());
+ rootNode2.getNode("mapNickFormatted").setValue(new TypeToken>() {},
+ ((SpongeFileNameManager)SpongeNameManager.getInstance()).getMapNickFormatted());
- } catch (IOException e) {
+ try {
+ configLoader.save(rootNode2);
+ System.out.println("[MultiChatSponge] SAVED NEW NICKNAME DATA!.");
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
- e.printStackTrace();
+ } catch (ObjectMappingException e) {
+ e.printStackTrace();
+ System.err.println("[MultiChatSponge] ERROR: Could not write nicknames :(");
+ }
- }
+ } else {
+
+ // First startup
+
+ // New file based storage
+ configLoader = HoconConfigurationLoader.builder().setFile(f).build();
+ ConfigurationNode rootNode;
+
+ Map mapUUIDNick;
+ Map mapNickUUID;
+ Map mapNickFormatted;
+
+ try {
- } catch (IOException e) {
+ rootNode = configLoader.load();
- e.printStackTrace();
- nicknames = new HashMap();
+ try {
+
+ mapUUIDNick = (Map) rootNode.getNode("mapUUIDNick").getValue(new TypeToken>() { /* EMPTY */ });
+ mapNickUUID = (Map) rootNode.getNode("mapNickUUID").getValue(new TypeToken>() { /* EMPTY */ });
+ mapNickFormatted = (Map) rootNode.getNode("mapNickFormatted").getValue(new TypeToken>() { /* EMPTY */ });
+
+ if (mapUUIDNick == null) {
+ mapUUIDNick = new HashMap();
+ mapNickUUID = new HashMap();
+ mapNickFormatted = new HashMap();
+ System.out.println("[MultiChatSponge] Created new nicknames maps for file storage!");
+ }
+
+ System.out.println("[MultiChatSponge] Nicknames appeared to load correctly!");
+
+ } catch (ClassCastException e) {
+
+ mapUUIDNick = new HashMap();
+ mapNickUUID = new HashMap();
+ mapNickFormatted = new HashMap();
+
+ } catch (ObjectMappingException e) {
+
+ mapUUIDNick = new HashMap();
+ mapNickUUID = new HashMap();
+ mapNickFormatted = new HashMap();
+
+ }
+
+ try {
+
+ configLoader.save(rootNode);
+
+ } catch (IOException e) {
+
+ e.printStackTrace();
+
+ }
+
+ } catch (IOException e) {
+
+ e.printStackTrace();
+ mapUUIDNick = new HashMap();
+ mapNickUUID = new HashMap();
+ mapNickFormatted = new HashMap();
+
+ }
+
+ ((SpongeFileNameManager)SpongeNameManager.getInstance()).loadFromFile(mapUUIDNick, mapNickUUID, mapNickFormatted);
+
+ }
}
@@ -196,6 +488,9 @@ public void onServerStart(GameStartedServerEvent event) {
ChannelBinding.RawDataChannel channelChannel = Sponge.getGame().getChannelRegistrar().createRawChannel(this, "multichat:ch");
ChannelBinding.RawDataChannel ignoreChannel = Sponge.getGame().getChannelRegistrar().createRawChannel(this, "multichat:ignore");
+ ChannelBinding.RawDataChannel pexecuteChannel = Sponge.getGame().getChannelRegistrar().createRawChannel(this, "multichat:pxe");
+ ChannelBinding.RawDataChannel ppexecuteChannel = Sponge.getGame().getChannelRegistrar().createRawChannel(this, "multichat:ppxe");
+
commChannel.addListener(Platform.Type.SERVER, new MetaListener(commChannel));
chatChannel.addListener(Platform.Type.SERVER, new BungeeChatListener(chatChannel));
channelChannel.addListener(Platform.Type.SERVER, new PlayerChannelListener());
@@ -218,6 +513,9 @@ public void onServerStart(GameStartedServerEvent event) {
MultiChatSponge.channelChannel = channelChannel;
MultiChatSponge.ignoreChannel = ignoreChannel;
+ MultiChatSponge.pexecuteChannel = pexecuteChannel;
+ MultiChatSponge.ppexecuteChannel = ppexecuteChannel;
+
// Register listeners
Sponge.getEventManager().registerListeners(this, new SpongeChatListener());
@@ -231,10 +529,43 @@ public void onServerStart(GameStartedServerEvent event) {
GenericArguments.onlyOne(GenericArguments.player(Text.of("player"))),
GenericArguments.remainingJoinedStrings(Text.of("message")))
.permission("multichatsponge.nick.self")
- .executor(this)
+ .executor(new SpongeNickCommand())
+ .build();
+
+ CommandSpec multichatspongeCommandSpec = CommandSpec.builder()
+ .description(Text.of("MultiChatSponge command"))
+ .arguments(GenericArguments.onlyOne(GenericArguments.string(Text.of("command"))))
+ .permission("multichatsponge.admin")
+ .executor(new MultiChatSpongeCommand())
+ .build();
+
+ CommandSpec realnameCommandSpec = CommandSpec.builder()
+ .description(Text.of("Sponge Realname Command"))
+ .arguments(GenericArguments.onlyOne(GenericArguments.string(Text.of("nickname"))))
+ .permission("multichatsponge.realname")
+ .executor(new SpongeRealnameCommand())
+ .build();
+
+ CommandSpec usernameCommandSpec = CommandSpec.builder()
+ .description(Text.of("Sponge Username Command"))
+ .arguments(GenericArguments.onlyOne(GenericArguments.string(Text.of("username"))))
+ .permission("multichatsponge.username")
+ .executor(new SpongeUsernameCommand())
+ .build();
+
+ CommandSpec pexecuteCommandSpec = CommandSpec.builder()
+ .description(Text.of("Sponge Proxy Execute Command"))
+ .arguments(
+ GenericArguments.remainingJoinedStrings(Text.of("message")))
+ .permission("multichatsponge.pexecute")
+ .executor(new SpongeProxyExecuteCommand())
.build();
Sponge.getCommandManager().register(this, nicknameCommandSpec, "nick");
+ Sponge.getCommandManager().register(this, multichatspongeCommandSpec, "multichatsponge");
+ Sponge.getCommandManager().register(this, realnameCommandSpec, "realname");
+ Sponge.getCommandManager().register(this, usernameCommandSpec, "username");
+ Sponge.getCommandManager().register(this, pexecuteCommandSpec, "pexecute", "pxe");
// Register message channel
@@ -265,24 +596,41 @@ public void onServerStop(GameStoppingServerEvent event) {
Sponge.getChannelRegistrar().unbindChannel(worldChannel);
Sponge.getChannelRegistrar().unbindChannel(channelChannel);
Sponge.getChannelRegistrar().unbindChannel(ignoreChannel);
+ Sponge.getChannelRegistrar().unbindChannel(pexecuteChannel);
+ Sponge.getChannelRegistrar().unbindChannel(ppexecuteChannel);
- ConfigurationNode rootNode;
+ if (nicknameSQL) {
+ try {
+ DatabaseManager.getInstance().getDatabase("multichatsponge.db").get().disconnectFromDatabase();
+ } catch (SQLException e1) {
+ e1.printStackTrace();
+ }
+ } else {
- rootNode = configLoader.createEmptyNode();
+ ConfigurationNode rootNode;
- try {
-
- rootNode.getNode("nicknames").setValue(new TypeToken>() {}, nicknames);
+ rootNode = configLoader.createEmptyNode();
try {
- configLoader.save(rootNode);
- } catch (IOException e) {
+
+ rootNode.getNode("mapUUIDNick").setValue(new TypeToken>() {},
+ ((SpongeFileNameManager)SpongeNameManager.getInstance()).getMapUUIDNick());
+ rootNode.getNode("mapNickUUID").setValue(new TypeToken>() {},
+ ((SpongeFileNameManager)SpongeNameManager.getInstance()).getMapNickUUID());
+ rootNode.getNode("mapNickFormatted").setValue(new TypeToken>() {},
+ ((SpongeFileNameManager)SpongeNameManager.getInstance()).getMapNickFormatted());
+
+ try {
+ configLoader.save(rootNode);
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+
+ } catch (ObjectMappingException e) {
e.printStackTrace();
+ System.err.println("[MultiChatSponge] ERROR: Could not write nicknames :(");
}
- } catch (ObjectMappingException e) {
- e.printStackTrace();
- System.err.println("[MultiChatSponge] ERROR: Could not write nicknames :(");
}
}
@@ -293,6 +641,18 @@ public static void sendChatToBungee(Player player, String message, String format
}
+ public static void sendProxyExecuteMessage(Player player, String message) {
+
+ pexecuteChannel.sendTo(player,buffer -> buffer.writeUTF(message));
+
+ }
+
+ public static void sendProxyExecutePlayerMessage(Player player, String message, String targetPlayer) {
+
+ ppexecuteChannel.sendTo(player,buffer -> buffer.writeUTF(message).writeUTF(targetPlayer));
+
+ }
+
public static void updatePlayerMeta(String playername, boolean setDisplayName, String displayNameFormat) {
if (!Sponge.getServer().getPlayer(playername).isPresent()) return;
@@ -302,11 +662,7 @@ public static void updatePlayerMeta(String playername, boolean setDisplayName, S
String prefix = "";
String suffix = "";
- if (nicknames.containsKey(player.getUniqueId())) {
- nickname = nicknames.get(player.getUniqueId());
- } else {
- nickname = player.getName();
- }
+ nickname = SpongeNameManager.getInstance().getCurrentName(player.getUniqueId());
final String fNickname = nickname;
nickChannel.sendTo(player,buffer -> buffer.writeUTF(player.getUniqueId().toString()).writeUTF(fNickname));
@@ -350,103 +706,4 @@ public static void updatePlayerMeta(String playername, boolean setDisplayName, S
}
- @Override
- public CommandResult execute(CommandSource sender, CommandContext args) throws CommandException {
-
- if (sender instanceof Player) {
- sender = (Player) sender;
- } else {
- sender.sendMessage(Text.of("Only players can use this command!"));
- return CommandResult.success();
- }
-
- Player target = args.getOne("player").get();
- String nickname = args.getOne("message").get();
-
- if (target != sender) {
- if (!sender.hasPermission("multichatsponge.nick.others")) {
- sender.sendMessage(Text.of("You do not have permission to nickname other players!"));
- return CommandResult.success();
- }
- }
-
- UUID targetUUID = target.getUniqueId();
-
- if (nickname.equalsIgnoreCase("off")) {
- removeNickname(targetUUID);
- updatePlayerMeta(target.getName(), setDisplayNameLastVal, displayNameFormatLastVal);
- sender.sendMessage(Text.of(target.getName() + " has had their nickname removed!"));
- return CommandResult.success();
- }
-
- String strippedNickname = stripAllFormattingCodes(nickname);
-
- UserStorageService uss = Sponge.getServiceManager().provideUnchecked(UserStorageService.class);
- Optional lookedUpName = uss.get(strippedNickname);
-
- // Check if a player name exists already (but not the name of this player)
- if (lookedUpName.isPresent() && !strippedNickname.equalsIgnoreCase(target.getName()) && !sender.hasPermission("multichatsponge.nick.impersonate")) {
- sender.sendMessage(Text.of("Sorry, a player already exists with this name!"));
- return CommandResult.success();
- }
-
- String targetNickname;
- if (nicknames.containsKey(targetUUID)) {
- targetNickname = stripAllFormattingCodes(nicknames.get(targetUUID));
- } else {
- targetNickname = target.getName();
- }
-
- // Check if a nickname exists already
- if (nicknames.values().stream()
- .map(nick -> stripAllFormattingCodes(nick))
- .anyMatch(nick -> nick.equalsIgnoreCase(strippedNickname))
- && !targetNickname.equalsIgnoreCase(strippedNickname) ) {
- //&& !sender.hasPermission("multichatsponge.nick.duplicate")) {
-
- sender.sendMessage(Text.of("Sorry, a player already has that nickname!"));
- return CommandResult.success();
-
- }
-
- boolean blacklisted = false;
- for (String bl : MultiChatSponge.nicknameBlacklist) {
- if (strippedNickname.matches(bl)) blacklisted = true;
- }
-
- if (blacklisted) {
-
- sender.sendMessage(Text.of("Sorry, this name is not allowed!"));
- return CommandResult.success();
-
- }
-
- addNickname(targetUUID,nickname);
- updatePlayerMeta(target.getName(), setDisplayNameLastVal, displayNameFormatLastVal);
-
- sender.sendMessage(Text.of(target.getName() + " has been nicknamed!"));
- return CommandResult.success();
- }
-
- private void addNickname(UUID uuid, String nickname) {
- nicknames.put(uuid,nickname);
- }
-
- private void removeNickname(UUID uuid) {
- nicknames.remove(uuid);
- }
-
- public String stripAllFormattingCodes(String input) {
-
- char COLOR_CHAR = '&';
- Pattern STRIP_COLOR_PATTERN = Pattern.compile("(?i)" + String.valueOf(COLOR_CHAR) + "[0-9A-FK-OR]");
-
- if (input == null) {
- return null;
- }
-
- return STRIP_COLOR_PATTERN.matcher(input).replaceAll("");
-
- }
-
}
diff --git a/multichat/src/main/java/xyz/olivermartin/multichat/spongebridge/SpongeFileNameManager.java b/multichat/src/main/java/xyz/olivermartin/multichat/spongebridge/SpongeFileNameManager.java
new file mode 100644
index 00000000..dd834f6e
--- /dev/null
+++ b/multichat/src/main/java/xyz/olivermartin/multichat/spongebridge/SpongeFileNameManager.java
@@ -0,0 +1,375 @@
+package xyz.olivermartin.multichat.spongebridge;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+import java.util.regex.PatternSyntaxException;
+
+import org.spongepowered.api.Sponge;
+import org.spongepowered.api.entity.living.player.Player;
+import org.spongepowered.api.entity.living.player.User;
+import org.spongepowered.api.profile.GameProfile;
+import org.spongepowered.api.service.user.UserStorageService;
+
+/**
+ * Player Name Manager
+ * Manages players names, uuids and nicknames
+ *
+ * @author Oliver Martin (Revilo410)
+ *
+ */
+public class SpongeFileNameManager extends SpongeNameManager {
+
+ private Map mapUUIDNick;
+ private Map mapNickUUID;
+ private Map mapNickFormatted;
+
+ public SpongeFileNameManager() {
+
+ super();
+
+ setDefaultData();
+
+ }
+
+ private void setDefaultData() {
+
+ mapUUIDNick = new HashMap();
+ mapNickUUID = new HashMap();
+
+ mapNickFormatted = new HashMap();
+
+ }
+
+ public Map getMapUUIDNick() {
+ return mapUUIDNick;
+ }
+ public Map