Plexus/Plex
1
0
Fork 0
mirror of https://github.com/plexusorg/Plex.git synced 2024-12-22 17:17:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

Start getting rid of legacy strings

Browse Source
This commit is contained in:
Telesphoreo 2022-03-17 17:16:17 -05:00
parent 8f7fed5835
commit 3c0b79ba06
14 changed files with 198 additions and 129 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
src/main/java/dev/plex/Plex.java
View File

@ -23,18 +23,18 @@ import dev.plex.util.PlexLog;
import dev.plex.util.PlexUtils; import dev.plex.util.PlexUtils;
import dev.plex.util.UpdateChecker; import dev.plex.util.UpdateChecker;
import dev.plex.world.CustomWorld; import dev.plex.world.CustomWorld;
import java.io.File;
import java.util.UUID;
import lombok.Getter; import lombok.Getter;
import lombok.Setter; import lombok.Setter;
import org.bstats.bukkit.Metrics; import org.bstats.bukkit.Metrics;
import org.bukkit.Bukkit; import org.bukkit.Bukkit;
import org.bukkit.plugin.java.JavaPlugin; import org.bukkit.plugin.java.JavaPlugin;
import java.io.File;
import java.util.UUID;
@Getter @Getter
@Setter @Setter
public class Plex extends JavaPlugin { public class Plex extends JavaPlugin
{
private static Plex plugin; private static Plex plugin;
public Config config; public Config config;
public Config messages; public Config messages;
@ -63,19 +63,24 @@ public class Plex extends JavaPlugin {
private String system; private String system;
public static Plex get() { public static Plex get()
{
return plugin; return plugin;
} }
@Override @Override
public void onLoad() { public void onLoad()
{
plugin = this; plugin = this;
config = new Config(this, "config.yml"); config = new Config(this, "config.yml");
messages = new Config(this, "messages.yml"); messages = new Config(this, "messages.yml");
indefBans = new Config(this, "indefbans.yml"); indefBans = new Config(this, "indefbans.yml");
modulesFolder = new File(this.getDataFolder() + File.separator + "modules"); modulesFolder = new File(this.getDataFolder() + File.separator + "modules");
if (!modulesFolder.exists()) modulesFolder.mkdir(); if (!modulesFolder.exists())
{
modulesFolder.mkdir();
}
sqlConnection = new SQLConnection(); sqlConnection = new SQLConnection();
mongoConnection = new MongoConnection(); mongoConnection = new MongoConnection();
@ -87,19 +92,24 @@ public class Plex extends JavaPlugin {
} }
@Override @Override
public void onEnable() { public void onEnable()
{
config.load(); config.load();
messages.load(); messages.load();
// Don't add default entries to indefinite ban file
indefBans.load(false); indefBans.load(false);
moduleManager.enableModules(); moduleManager.enableModules();
system = config.getString("commands.permissions"); system = config.getString("commands.permissions");
try { try
{
PlexUtils.testConnections(); PlexUtils.testConnections();
PlexLog.log("Connected to " + storageType.name().toUpperCase()); PlexLog.log("Connected to " + storageType.name().toUpperCase());
} catch (Exception e) { }
catch (Exception e)
{
PlexLog.error("Failed to connect to " + storageType.name().toUpperCase()); PlexLog.error("Failed to connect to " + storageType.name().toUpperCase());
e.printStackTrace(); e.printStackTrace();
} }
@ -111,16 +121,22 @@ public class Plex extends JavaPlugin {
Metrics metrics = new Metrics(this, 14143); Metrics metrics = new Metrics(this, 14143);
PlexLog.log("Enabled Metrics"); PlexLog.log("Enabled Metrics");
if (redisConnection.isEnabled()) { if (redisConnection.isEnabled())
{
redisConnection.getJedis(); redisConnection.getJedis();
PlexLog.log("Connected to Redis!"); PlexLog.log("Connected to Redis!");
} else { }
else
{
PlexLog.log("Redis is disabled in the configuration file, not connecting."); PlexLog.log("Redis is disabled in the configuration file, not connecting.");
} }
if (storageType == StorageType.MONGODB) { if (storageType == StorageType.MONGODB)
{
mongoPlayerData = new MongoPlayerData(); mongoPlayerData = new MongoPlayerData();
} else { }
else
{
sqlPlayerData = new SQLPlayerData(); sqlPlayerData = new SQLPlayerData();
} }
@ -148,24 +164,28 @@ public class Plex extends JavaPlugin {
} }
@Override @Override
public void onDisable() { public void onDisable()
{
Bukkit.getOnlinePlayers().forEach(player -> Bukkit.getOnlinePlayers().forEach(player ->
{ {
PlexPlayer plexPlayer = PlayerCache.getPlexPlayerMap().get(player.getUniqueId()); //get the player because it's literally impossible for them to not have an object PlexPlayer plexPlayer = PlayerCache.getPlexPlayerMap().get(player.getUniqueId()); //get the player because it's literally impossible for them to not have an object
if (plugin.getRankManager().isAdmin(plexPlayer)) { if (plugin.getRankManager().isAdmin(plexPlayer))
{
plugin.getAdminList().removeFromCache(UUID.fromString(plexPlayer.getUuid())); plugin.getAdminList().removeFromCache(UUID.fromString(plexPlayer.getUuid()));
} }
if (mongoPlayerData != null) //back to mongo checking if (mongoPlayerData != null) //back to mongo checking
{ {
mongoPlayerData.update(plexPlayer); //update the player's document mongoPlayerData.update(plexPlayer); //update the player's document
} else if (sqlPlayerData != null) //sql checking }
else if (sqlPlayerData != null) //sql checking
{ {
sqlPlayerData.update(plexPlayer); sqlPlayerData.update(plexPlayer);
} }
}); });
if (redisConnection.isEnabled() && redisConnection.getJedis().isConnected()) { if (redisConnection.isEnabled() && redisConnection.getJedis().isConnected())
{
PlexLog.log("Disabling Redis/Jedis. No memory leaks in this Anarchy server!"); PlexLog.log("Disabling Redis/Jedis. No memory leaks in this Anarchy server!");
redisConnection.getJedis().close(); redisConnection.getJedis().close();
} }
@ -173,21 +193,25 @@ public class Plex extends JavaPlugin {
moduleManager.disableModules(); moduleManager.disableModules();
} }
private void generateWorlds() { private void generateWorlds()
{
PlexLog.log("Generating any worlds if needed..."); PlexLog.log("Generating any worlds if needed...");
for (String key : config.getConfigurationSection("worlds").getKeys(false)) { for (String key : config.getConfigurationSection("worlds").getKeys(false))
{
CustomWorld.generateConfigFlatWorld(key); CustomWorld.generateConfigFlatWorld(key);
} }
PlexLog.log("Finished with world generation!"); PlexLog.log("Finished with world generation!");
} }
private void reloadPlayers() { private void reloadPlayers()
{
Bukkit.getOnlinePlayers().forEach(player -> Bukkit.getOnlinePlayers().forEach(player ->
{ {
PlexPlayer plexPlayer = DataUtils.getPlayer(player.getUniqueId()); PlexPlayer plexPlayer = DataUtils.getPlayer(player.getUniqueId());
PlayerCache.getPlexPlayerMap().put(player.getUniqueId(), plexPlayer); //put them into the cache PlayerCache.getPlexPlayerMap().put(player.getUniqueId(), plexPlayer); //put them into the cache
PlayerCache.getPunishedPlayerMap().put(player.getUniqueId(), new PunishedPlayer(player.getUniqueId())); PlayerCache.getPunishedPlayerMap().put(player.getUniqueId(), new PunishedPlayer(player.getUniqueId()));
if (plugin.getRankManager().isAdmin(plexPlayer)) { if (plugin.getRankManager().isAdmin(plexPlayer))
{
Admin admin = new Admin(UUID.fromString(plexPlayer.getUuid())); Admin admin = new Admin(UUID.fromString(plexPlayer.getUuid()));
admin.setRank(plexPlayer.getRankFromString()); admin.setRank(plexPlayer.getRankFromString());

1
src/main/java/dev/plex/admin/AdminList.java
View File

@ -4,7 +4,6 @@ import com.google.common.collect.Lists;
import com.google.common.collect.Maps; import com.google.common.collect.Maps;
import dev.morphia.Datastore; import dev.morphia.Datastore;
import dev.morphia.query.Query; import dev.morphia.query.Query;
import dev.plex.Plex;
import dev.plex.PlexBase; import dev.plex.PlexBase;
import dev.plex.player.PlexPlayer; import dev.plex.player.PlexPlayer;
import dev.plex.rank.enums.Rank; import dev.plex.rank.enums.Rank;

46
src/main/java/dev/plex/command/PlexCommand.java
View File

@ -19,6 +19,7 @@ import java.util.Arrays;
import java.util.UUID; import java.util.UUID;
import net.kyori.adventure.audience.Audience; import net.kyori.adventure.audience.Audience;
import net.kyori.adventure.text.Component; import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.format.NamedTextColor;
import net.kyori.adventure.text.minimessage.MiniMessage; import net.kyori.adventure.text.minimessage.MiniMessage;
import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer; import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
import org.bukkit.Bukkit; import org.bukkit.Bukkit;
@ -90,9 +91,8 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
* Executes the command * Executes the command
* *
* @param sender The sender of the command * @param sender The sender of the command
* @param playerSender The player who executed the command (null if command source is console or if command source is any but console executed) * @param playerSender The player who executed the command (null if CommandSource is console or if CommandSource is any but console executed)
* @param args A Kyori Component to send to the sender (can be null) * @param args A Kyori Component to send to the sender (can be null)
* @return
*/ */
protected abstract Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, @NotNull String[] args); protected abstract Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, @NotNull String[] args);
@ -165,9 +165,9 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
} }
/** /**
* Checks if the string given is a command string * Checks if the String given is a matching command
* *
* @param label The string to check * @param label The String to check
* @return true if the string is a command name or alias * @return true if the string is a command name or alias
*/ */
private boolean matches(String label) private boolean matches(String label)
@ -202,9 +202,9 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
} }
/** /**
* Sends a message to an audience * Sends a message to an Audience
* *
* @param audience The audience to send the message to * @param audience The Audience to send the message to
* @param s The message to send * @param s The message to send
*/ */
protected void send(Audience audience, String s) protected void send(Audience audience, String s)
@ -213,10 +213,10 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
} }
/** /**
* Sends a message to an audience * Sends a message to an Audience
* *
* @param audience The audience to send the message to * @param audience The Audience to send the message to
* @param component The component to send * @param component The Component to send
*/ */
protected void send(Audience audience, Component component) protected void send(Audience audience, Component component)
{ {
@ -226,7 +226,7 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
/** /**
* Checks whether a sender has enough permissions or is high enough a rank * Checks whether a sender has enough permissions or is high enough a rank
* *
* @param sender A command sender * @param sender A CommandSender
* @param rank The rank to check (if the server is using ranks) * @param rank The rank to check (if the server is using ranks)
* @param permission The permission to check (if the server is using permissions) * @param permission The permission to check (if the server is using permissions)
* @return true if the sender has enough permissions * @return true if the sender has enough permissions
@ -415,7 +415,7 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
* *
* @param s The message entry * @param s The message entry
* @param objects Any objects to replace in order * @param objects Any objects to replace in order
* @return A Kyori component * @return A Kyori Component
*/ */
protected Component messageComponent(String s, Object... objects) protected Component messageComponent(String s, Object... objects)
{ {
@ -435,25 +435,25 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
} }
/** /**
* Converts usage to a component * Converts usage to a Component
* *
* @return A Kyori component stating the usage * @return A Kyori Component stating the usage
*/ */
protected Component usage() protected Component usage()
{ {
return componentFromString(ChatColor.YELLOW + "Correct Usage: " + ChatColor.GRAY + this.getUsage()); return Component.text("Correct Usage: ").color(NamedTextColor.YELLOW).append(componentFromString(this.getUsage()).color(NamedTextColor.GRAY));
} }
/** /**
* Converts usage to a component * Converts usage to a Component
* <p> * <p>
* s The usage to convert * s The usage to convert
* *
* @return A Kyori component stating the usage * @return A Kyori Component stating the usage
*/ */
protected Component usage(String s) protected Component usage(String s)
{ {
return componentFromString(ChatColor.YELLOW + "Correct Usage: " + ChatColor.GRAY + s); return Component.text("Correct Usage: ").color(NamedTextColor.YELLOW).append(componentFromString(s).color(NamedTextColor.GRAY));
} }
protected Player getNonNullPlayer(String name) protected Player getNonNullPlayer(String name)
@ -498,21 +498,21 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
} }
/** /**
* Converts a string to a legacy Kyori component * Converts a String to a legacy Kyori Component
* *
* @param s The string to convert * @param s The String to convert
* @return A Kyori component * @return A Kyori component
*/ */
protected Component componentFromString(String s) protected Component componentFromString(String s)
{ {
return LegacyComponentSerializer.legacyAmpersand().deserialize(s); return LegacyComponentSerializer.legacyAmpersand().deserialize(s).colorIfAbsent(NamedTextColor.GRAY);
} }
/** /**
* Converts a string to a mini message kyori component * Converts a String to a MiniMessage Component
* *
* @param s The string to convert * @param s The String to convert
* @return A Kyori component * @return A Kyori Component
*/ */
protected Component mmString(String s) protected Component mmString(String s)
{ {

7
src/main/java/dev/plex/command/impl/LockupCMD.java
View File

@ -7,20 +7,15 @@ import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions; import dev.plex.command.annotation.CommandPermissions;
import dev.plex.player.PlexPlayer; import dev.plex.player.PlexPlayer;
import dev.plex.player.PunishedPlayer; import dev.plex.player.PunishedPlayer;
import dev.plex.punishment.Punishment;
import dev.plex.punishment.PunishmentType;
import dev.plex.rank.enums.Rank; import dev.plex.rank.enums.Rank;
import dev.plex.util.PlexUtils; import dev.plex.util.PlexUtils;
import java.util.List;
import net.kyori.adventure.text.Component; import net.kyori.adventure.text.Component;
import org.bukkit.command.CommandSender; import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.Nullable;
import java.time.LocalDateTime;
import java.util.List;
import java.util.UUID;
@CommandParameters(name = "lockup", description = "Lockup a player on the server", usage = "/<command> <player>") @CommandParameters(name = "lockup", description = "Lockup a player on the server", usage = "/<command> <player>")
@CommandPermissions(level = Rank.ADMIN, permission = "plex.lockup") @CommandPermissions(level = Rank.ADMIN, permission = "plex.lockup")
public class LockupCMD extends PlexCommand public class LockupCMD extends PlexCommand

1
src/main/java/dev/plex/command/impl/NameHistoryCMD.java
View File

@ -15,7 +15,6 @@ import java.util.Arrays;
import java.util.List; import java.util.List;
import net.kyori.adventure.text.Component; import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.format.NamedTextColor; import net.kyori.adventure.text.format.NamedTextColor;
import net.kyori.adventure.text.format.TextDecoration;
import org.bukkit.command.CommandSender; import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;

34
src/main/java/dev/plex/command/impl/PlexCMD.java
View File

@ -9,18 +9,16 @@ import dev.plex.command.source.RequiredCommandSource;
import dev.plex.module.PlexModule; import dev.plex.module.PlexModule;
import dev.plex.module.PlexModuleFile; import dev.plex.module.PlexModuleFile;
import dev.plex.rank.enums.Rank; import dev.plex.rank.enums.Rank;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
import net.kyori.adventure.text.Component; import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.minimessage.MiniMessage;
import org.apache.commons.lang.StringUtils; import org.apache.commons.lang.StringUtils;
import org.bukkit.ChatColor;
import org.bukkit.command.CommandSender; import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.Nullable;
import java.util.List;
import java.util.stream.Collectors;
@CommandPermissions(level = Rank.OP, permission = "plex.plex", source = RequiredCommandSource.ANY) @CommandPermissions(level = Rank.OP, permission = "plex.plex", source = RequiredCommandSource.ANY)
@CommandParameters(name = "plex", usage = "/<command> [reload | redis | modules [reload]]", description = "Show information about Plex or reload it") @CommandParameters(name = "plex", usage = "/<command> [reload | redis | modules [reload]]", description = "Show information about Plex or reload it")
public class PlexCMD extends PlexCommand public class PlexCMD extends PlexCommand
@ -31,10 +29,11 @@ public class PlexCMD extends PlexCommand
{ {
if (args.length == 0) if (args.length == 0)
{ {
send(sender, ChatColor.LIGHT_PURPLE + "Plex - A new freedom plugin."); send(sender, mmString("<light_purple>Plex - A new freedom plugin."));
send(sender, ChatColor.LIGHT_PURPLE + "Plugin version: " + plugin.getDescription().getVersion()); send(sender, mmString("<light_purple>Plugin version: <gold>" + plugin.getDescription().getVersion()));
send(sender, ChatColor.LIGHT_PURPLE + "Authors: " + ChatColor.GOLD + "Telesphoreo, Taahh"); send(sender, mmString("<light_purple>Authors: <gold>Telesphoreo, Taahh"));
return componentFromString(ChatColor.LIGHT_PURPLE + "Run " + ChatColor.GOLD + "/plex modules" + ChatColor.LIGHT_PURPLE + " to see a list of modules."); send(sender, mmString("<light_purple>Run <gold>/plex modules <light_purple>to see a list of modules."));
return null;
} }
if (args[0].equalsIgnoreCase("reload")) if (args[0].equalsIgnoreCase("reload"))
{ {
@ -49,6 +48,7 @@ public class PlexCMD extends PlexCommand
plugin.getRankManager().importDefaultRanks(); plugin.getRankManager().importDefaultRanks();
send(sender, "Imported ranks"); send(sender, "Imported ranks");
send(sender, "Plex successfully reloaded."); send(sender, "Plex successfully reloaded.");
return null;
} }
else if (args[0].equalsIgnoreCase("redis")) else if (args[0].equalsIgnoreCase("redis"))
{ {
@ -61,12 +61,13 @@ public class PlexCMD extends PlexCommand
send(sender, "Set test to 123. Now outputting key test..."); send(sender, "Set test to 123. Now outputting key test...");
send(sender, plugin.getRedisConnection().getJedis().get("test")); send(sender, plugin.getRedisConnection().getJedis().get("test"));
plugin.getRedisConnection().getJedis().close(); plugin.getRedisConnection().getJedis().close();
return null;
} }
if (args[0].equalsIgnoreCase("modules")) else if (args[0].equalsIgnoreCase("modules"))
{ {
if (args.length == 1) if (args.length == 1)
{ {
return MiniMessage.miniMessage().deserialize("<gold>Modules (" + plugin.getModuleManager().getModules().size() + "): <yellow>" + StringUtils.join(plugin.getModuleManager().getModules().stream().map(PlexModule::getPlexModuleFile).map(PlexModuleFile::getName).collect(Collectors.toList()), ", ")); return mmString("<gold>Modules (" + plugin.getModuleManager().getModules().size() + "): <yellow>" + StringUtils.join(plugin.getModuleManager().getModules().stream().map(PlexModule::getPlexModuleFile).map(PlexModuleFile::getName).collect(Collectors.toList()), ", "));
} }
if (args[1].equalsIgnoreCase("reload")) if (args[1].equalsIgnoreCase("reload"))
{ {
@ -74,6 +75,7 @@ public class PlexCMD extends PlexCommand
plugin.getModuleManager().loadAllModules(); plugin.getModuleManager().loadAllModules();
plugin.getModuleManager().loadModules(); plugin.getModuleManager().loadModules();
plugin.getModuleManager().enableModules(); plugin.getModuleManager().enableModules();
return null;
} }
} }
else else
@ -86,6 +88,14 @@ public class PlexCMD extends PlexCommand
@Override @Override
public @NotNull List<String> tabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException public @NotNull List<String> tabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{ {
return ImmutableList.of("reload", "redis"); if (args.length == 0)
{
return ImmutableList.of("reload", "redis", "modules");
}
if (args[0].equalsIgnoreCase("modules"))
{
return ImmutableList.of("reload");
}
return Collections.emptyList();
} }
} }

47
src/main/java/dev/plex/config/Config.java
View File

@ -2,16 +2,16 @@ package dev.plex.config;
import dev.plex.Plex; import dev.plex.Plex;
import dev.plex.util.PlexLog; import dev.plex.util.PlexLog;
import org.bukkit.configuration.file.YamlConfiguration;
import java.io.File; import java.io.File;
import java.io.InputStreamReader; import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets; import java.nio.charset.StandardCharsets;
import org.bukkit.configuration.file.YamlConfiguration;
/** /**
* Creates a custom Config object * Creates a custom Config object
*/ */
public class Config extends YamlConfiguration { public class Config extends YamlConfiguration
{
/** /**
* The plugin instance * The plugin instance
*/ */
@ -38,12 +38,14 @@ public class Config extends YamlConfiguration {
* @param plugin The plugin instance * @param plugin The plugin instance
* @param name The file name * @param name The file name
*/ */
public Config(Plex plugin, String name) { public Config(Plex plugin, String name)
{
this.plugin = plugin; this.plugin = plugin;
this.file = new File(plugin.getDataFolder(), name); this.file = new File(plugin.getDataFolder(), name);
this.name = name; this.name = name;
if (!file.exists()) { if (!file.exists())
{
saveDefault(); saveDefault();
} }
} }
@ -56,17 +58,22 @@ public class Config extends YamlConfiguration {
/** /**
* Loads the configuration file * Loads the configuration file
*/ */
public void load(boolean loadFromFile) { public void load(boolean loadFromFile)
try { {
if (loadFromFile) { try
{
if (loadFromFile)
{
YamlConfiguration externalYamlConfig = YamlConfiguration.loadConfiguration(file); YamlConfiguration externalYamlConfig = YamlConfiguration.loadConfiguration(file);
InputStreamReader internalConfigFileStream = new InputStreamReader(Plex.get().getResource(name), StandardCharsets.UTF_8); InputStreamReader internalConfigFileStream = new InputStreamReader(Plex.get().getResource(name), StandardCharsets.UTF_8);
YamlConfiguration internalYamlConfig = YamlConfiguration.loadConfiguration(internalConfigFileStream); YamlConfiguration internalYamlConfig = YamlConfiguration.loadConfiguration(internalConfigFileStream);
// Gets all the keys inside the internal file and iterates through all of it's key pairs // Gets all the keys inside the internal file and iterates through all of it's key pairs
for (String string : internalYamlConfig.getKeys(true)) { for (String string : internalYamlConfig.getKeys(true))
{
// Checks if the external file contains the key already. // Checks if the external file contains the key already.
if (!externalYamlConfig.contains(string)) { if (!externalYamlConfig.contains(string))
{
// If it doesn't contain the key, we set the key based off what was found inside the plugin jar // If it doesn't contain the key, we set the key based off what was found inside the plugin jar
externalYamlConfig.setComments(string, internalYamlConfig.getComments(string)); externalYamlConfig.setComments(string, internalYamlConfig.getComments(string));
externalYamlConfig.set(string, internalYamlConfig.get(string)); externalYamlConfig.set(string, internalYamlConfig.get(string));
@ -74,14 +81,17 @@ public class Config extends YamlConfiguration {
added = true; added = true;
} }
} }
if (added) { if (added)
{
externalYamlConfig.save(file); externalYamlConfig.save(file);
PlexLog.log("Saving new file..."); PlexLog.log("Saving new file...");
added = false; added = false;
} }
} }
super.load(file); super.load(file);
} catch (Exception ex) { }
catch (Exception ex)
{
ex.printStackTrace(); ex.printStackTrace();
} }
} }
@ -89,10 +99,14 @@ public class Config extends YamlConfiguration {
/** /**
* Saves the configuration file * Saves the configuration file
*/ */
public void save() { public void save()
try { {
try
{
super.save(file); super.save(file);
} catch (Exception ex) { }
catch (Exception ex)
{
ex.printStackTrace(); ex.printStackTrace();
} }
} }
@ -100,7 +114,8 @@ public class Config extends YamlConfiguration {
/** /**
* Moves the configuration file from the plugin's resources folder to the data folder (plugins/Plex/) * Moves the configuration file from the plugin's resources folder to the data folder (plugins/Plex/)
*/ */
private void saveDefault() { private void saveDefault()
{
plugin.saveResource(name, false); plugin.saveResource(name, false);
} }
} }

67
src/main/java/dev/plex/module/ModuleManager.java
View File

@ -4,10 +4,6 @@ import com.google.common.collect.Lists;
import dev.plex.Plex; import dev.plex.Plex;
import dev.plex.module.exception.ModuleLoadException; import dev.plex.module.exception.ModuleLoadException;
import dev.plex.util.PlexLog; import dev.plex.util.PlexLog;
import lombok.Getter;
import org.apache.logging.log4j.LogManager;
import org.bukkit.configuration.file.YamlConfiguration;
import java.io.File; import java.io.File;
import java.io.IOException; import java.io.IOException;
import java.io.InputStreamReader; import java.io.InputStreamReader;
@ -18,18 +14,26 @@ import java.net.URLClassLoader;
import java.nio.charset.StandardCharsets; import java.nio.charset.StandardCharsets;
import java.util.Arrays; import java.util.Arrays;
import java.util.List; import java.util.List;
import lombok.Getter;
import org.apache.logging.log4j.LogManager;
import org.bukkit.configuration.file.YamlConfiguration;
@Getter @Getter
public class ModuleManager { public class ModuleManager
{
private final List<PlexModule> modules = Lists.newArrayList(); private final List<PlexModule> modules = Lists.newArrayList();
public void loadAllModules() { public void loadAllModules()
{
this.modules.clear(); this.modules.clear();
PlexLog.debug(String.valueOf(Plex.get().getModulesFolder().listFiles().length)); PlexLog.debug(String.valueOf(Plex.get().getModulesFolder().listFiles().length));
Arrays.stream(Plex.get().getModulesFolder().listFiles()).forEach(file -> { Arrays.stream(Plex.get().getModulesFolder().listFiles()).forEach(file ->
if (file.getName().endsWith(".jar")) { {
try { if (file.getName().endsWith(".jar"))
{
try
{
URLClassLoader loader = new URLClassLoader( URLClassLoader loader = new URLClassLoader(
new URL[]{file.toURI().toURL()}, new URL[]{file.toURI().toURL()},
Plex.class.getClassLoader() Plex.class.getClassLoader()
@ -54,42 +58,54 @@ public class ModuleManager {
String version = internalModuleConfig.getString("version", "1.0"); String version = internalModuleConfig.getString("version", "1.0");
PlexModuleFile plexModuleFile = new PlexModuleFile(name, main, description, version); PlexModuleFile plexModuleFile = new PlexModuleFile(name, main, description, version);
Class<? extends PlexModule> module = (Class<? extends PlexModule>) Class.forName(main, true, loader); Class<? extends PlexModule> module = (Class<? extends PlexModule>)Class.forName(main, true, loader);
PlexModule plexModule = module.getConstructor().newInstance(); PlexModule plexModule = module.getConstructor().newInstance();
plexModule.setPlex(Plex.get()); plexModule.setPlex(Plex.get());
plexModule.setPlexModuleFile(plexModuleFile); plexModule.setPlexModuleFile(plexModuleFile);
plexModule.setDataFolder(new File(Plex.get().getModulesFolder() + File.separator + plexModuleFile.getName())); plexModule.setDataFolder(new File(Plex.get().getModulesFolder() + File.separator + plexModuleFile.getName()));
if (!plexModule.getDataFolder().exists()) plexModule.getDataFolder().mkdir(); if (!plexModule.getDataFolder().exists())
{
plexModule.getDataFolder().mkdir();
}
plexModule.setLogger(LogManager.getLogger(plexModuleFile.getName())); plexModule.setLogger(LogManager.getLogger(plexModuleFile.getName()));
modules.add(plexModule); modules.add(plexModule);
} catch (MalformedURLException | ClassNotFoundException | InvocationTargetException | InstantiationException | IllegalAccessException | NoSuchMethodException e) { }
catch (MalformedURLException | ClassNotFoundException | InvocationTargetException | InstantiationException | IllegalAccessException | NoSuchMethodException e)
{
e.printStackTrace(); e.printStackTrace();
} }
} }
}); });
} }
public void loadModules() { public void loadModules()
this.modules.forEach(module -> { {
this.modules.forEach(module ->
{
PlexLog.log("Loading module " + module.getPlexModuleFile().getName() + " with version " + module.getPlexModuleFile().getVersion()); PlexLog.log("Loading module " + module.getPlexModuleFile().getName() + " with version " + module.getPlexModuleFile().getVersion());
module.load(); module.load();
}); });
} }
public void enableModules() { public void enableModules()
this.modules.forEach(module -> { {
this.modules.forEach(module ->
{
PlexLog.log("Enabling module " + module.getPlexModuleFile().getName() + " with version " + module.getPlexModuleFile().getVersion()); PlexLog.log("Enabling module " + module.getPlexModuleFile().getName() + " with version " + module.getPlexModuleFile().getVersion());
module.enable(); module.enable();
}); });
} }
public void disableModules() { public void disableModules()
this.modules.forEach(module -> { {
this.modules.forEach(module ->
{
PlexLog.log("Disabling module " + module.getPlexModuleFile().getName() + " with version " + module.getPlexModuleFile().getVersion()); PlexLog.log("Disabling module " + module.getPlexModuleFile().getName() + " with version " + module.getPlexModuleFile().getVersion());
module.getCommands().stream().toList().forEach(plexCommand -> { module.getCommands().stream().toList().forEach(plexCommand ->
{
module.unregisterCommand(plexCommand); module.unregisterCommand(plexCommand);
Plex.get().getServer().getCommandMap().getKnownCommands().remove(plexCommand.getName()); Plex.get().getServer().getCommandMap().getKnownCommands().remove(plexCommand.getName());
plexCommand.getAliases().forEach(alias -> Plex.get().getServer().getCommandMap().getKnownCommands().remove(alias)); plexCommand.getAliases().forEach(alias -> Plex.get().getServer().getCommandMap().getKnownCommands().remove(alias));
@ -99,12 +115,17 @@ public class ModuleManager {
}); });
} }
public void unloadModules() { public void unloadModules()
{
this.disableModules(); this.disableModules();
this.modules.forEach(module -> { this.modules.forEach(module ->
try { {
try
{
((URLClassLoader)module.getClass().getClassLoader()).close(); ((URLClassLoader)module.getClass().getClassLoader()).close();
} catch (IOException e) { }
catch (IOException e)
{
e.printStackTrace(); e.printStackTrace();
} }
}); });

25
src/main/java/dev/plex/module/PlexModule.java
View File

@ -4,17 +4,14 @@ import com.google.common.collect.Lists;
import dev.plex.Plex; import dev.plex.Plex;
import dev.plex.command.PlexCommand; import dev.plex.command.PlexCommand;
import dev.plex.listener.PlexListener; import dev.plex.listener.PlexListener;
import lombok.AccessLevel;
import lombok.Getter;
import lombok.Setter;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.bukkit.event.HandlerList;
import java.io.File; import java.io.File;
import java.util.List; import java.util.List;
import java.util.Locale; import java.util.Locale;
import java.util.stream.Collectors; import lombok.AccessLevel;
import lombok.Getter;
import lombok.Setter;
import org.apache.logging.log4j.Logger;
import org.bukkit.event.HandlerList;
@Getter @Getter
@Setter(AccessLevel.MODULE) @Setter(AccessLevel.MODULE)
@ -31,11 +28,17 @@ public abstract class PlexModule
private File dataFolder; private File dataFolder;
private Logger logger; private Logger logger;
public void load() {} public void load()
{
}
public void enable() {} public void enable()
{
}
public void disable() {} public void disable()
{
}
public void registerListener(PlexListener listener) public void registerListener(PlexListener listener)
{ {

1
src/main/java/dev/plex/punishment/Punishment.java
View File

@ -30,6 +30,7 @@ public class Punishment
private boolean customTime; private boolean customTime;
private boolean active; // Field is only for bans private boolean active; // Field is only for bans
private LocalDateTime endDate; private LocalDateTime endDate;
public Punishment(UUID punished, UUID punisher) public Punishment(UUID punished, UUID punisher)
{ {
this.punished = punished; this.punished = punished;

22
src/main/java/dev/plex/punishment/PunishmentManager.java
View File

@ -7,7 +7,6 @@ import com.google.gson.Gson;
import dev.plex.Plex; import dev.plex.Plex;
import dev.plex.PlexBase; import dev.plex.PlexBase;
import dev.plex.cache.PlayerCache; import dev.plex.cache.PlayerCache;
import dev.plex.player.PlexPlayer;
import dev.plex.player.PunishedPlayer; import dev.plex.player.PunishedPlayer;
import dev.plex.util.PlexLog; import dev.plex.util.PlexLog;
import dev.plex.util.PlexUtils; import dev.plex.util.PlexUtils;
@ -15,7 +14,6 @@ import java.io.File;
import java.io.FileInputStream; import java.io.FileInputStream;
import java.io.FileWriter; import java.io.FileWriter;
import java.io.IOException; import java.io.IOException;
import java.lang.reflect.Type;
import java.nio.charset.StandardCharsets; import java.nio.charset.StandardCharsets;
import java.time.LocalDateTime; import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit; import java.time.temporal.ChronoUnit;
@ -24,11 +22,9 @@ import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.UUID; import java.util.UUID;
import java.util.stream.Collectors; import java.util.stream.Collectors;
import lombok.Data; import lombok.Data;
import org.apache.commons.io.FileUtils; import org.apache.commons.io.FileUtils;
import org.bukkit.Bukkit; import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.bukkit.scheduler.BukkitRunnable; import org.bukkit.scheduler.BukkitRunnable;
import org.json.JSONObject; import org.json.JSONObject;
import org.json.JSONTokener; import org.json.JSONTokener;
@ -41,7 +37,8 @@ public class PunishmentManager extends PlexBase
public void mergeIndefiniteBans() public void mergeIndefiniteBans()
{ {
this.indefiniteBans.clear(); this.indefiniteBans.clear();
Plex.get().indefBans.getKeys(false).forEach(key -> { Plex.get().indefBans.getKeys(false).forEach(key ->
{
IndefiniteBan ban = new IndefiniteBan(); IndefiniteBan ban = new IndefiniteBan();
ban.ips.addAll(Plex.get().getIndefBans().getStringList(key + ".ips")); ban.ips.addAll(Plex.get().getIndefBans().getStringList(key + ".ips"));
ban.usernames.addAll(Plex.get().getIndefBans().getStringList(key + ".users")); ban.usernames.addAll(Plex.get().getIndefBans().getStringList(key + ".users"));
@ -54,7 +51,8 @@ public class PunishmentManager extends PlexBase
if (Plex.get().getRedisConnection().isEnabled()) if (Plex.get().getRedisConnection().isEnabled())
{ {
PlexLog.log("Asynchronously uploading all indefinite bans to Redis"); PlexLog.log("Asynchronously uploading all indefinite bans to Redis");
Plex.get().getRedisConnection().runAsync(jedis -> { Plex.get().getRedisConnection().runAsync(jedis ->
{
jedis.set("indefbans", new Gson().toJson(indefiniteBans)); jedis.set("indefbans", new Gson().toJson(indefiniteBans));
}); });
} }
@ -65,7 +63,9 @@ public class PunishmentManager extends PlexBase
if (Plex.get().getRedisConnection().isEnabled()) if (Plex.get().getRedisConnection().isEnabled())
{ {
PlexLog.debug("Checking if UUID is banned in Redis"); PlexLog.debug("Checking if UUID is banned in Redis");
List<IndefiniteBan> bans = new Gson().fromJson(Plex.get().getRedisConnection().getJedis().get("indefbans"), new TypeToken<List<IndefiniteBan>>(){}.getType()); List<IndefiniteBan> bans = new Gson().fromJson(Plex.get().getRedisConnection().getJedis().get("indefbans"), new TypeToken<List<IndefiniteBan>>()
{
}.getType());
return bans.stream().anyMatch(indefiniteBan -> indefiniteBan.getUuids().contains(uuid)); return bans.stream().anyMatch(indefiniteBan -> indefiniteBan.getUuids().contains(uuid));
} }
return this.indefiniteBans.stream().anyMatch(indefiniteBan -> indefiniteBan.getUuids().contains(uuid)); return this.indefiniteBans.stream().anyMatch(indefiniteBan -> indefiniteBan.getUuids().contains(uuid));
@ -76,7 +76,9 @@ public class PunishmentManager extends PlexBase
if (Plex.get().getRedisConnection().isEnabled()) if (Plex.get().getRedisConnection().isEnabled())
{ {
PlexLog.debug("Checking if IP is banned in Redis"); PlexLog.debug("Checking if IP is banned in Redis");
List<IndefiniteBan> bans = new Gson().fromJson(Plex.get().getRedisConnection().getJedis().get("indefbans"), new TypeToken<List<IndefiniteBan>>(){}.getType()); List<IndefiniteBan> bans = new Gson().fromJson(Plex.get().getRedisConnection().getJedis().get("indefbans"), new TypeToken<List<IndefiniteBan>>()
{
}.getType());
return bans.stream().anyMatch(indefiniteBan -> indefiniteBan.getIps().contains(ip)); return bans.stream().anyMatch(indefiniteBan -> indefiniteBan.getIps().contains(ip));
} }
return this.indefiniteBans.stream().anyMatch(indefiniteBan -> indefiniteBan.getIps().contains(ip)); return this.indefiniteBans.stream().anyMatch(indefiniteBan -> indefiniteBan.getIps().contains(ip));
@ -87,7 +89,9 @@ public class PunishmentManager extends PlexBase
if (Plex.get().getRedisConnection().isEnabled()) if (Plex.get().getRedisConnection().isEnabled())
{ {
PlexLog.debug("Checking if username is banned in Redis"); PlexLog.debug("Checking if username is banned in Redis");
List<IndefiniteBan> bans = new Gson().fromJson(Plex.get().getRedisConnection().getJedis().get("indefbans"), new TypeToken<List<IndefiniteBan>>(){}.getType()); List<IndefiniteBan> bans = new Gson().fromJson(Plex.get().getRedisConnection().getJedis().get("indefbans"), new TypeToken<List<IndefiniteBan>>()
{
}.getType());
return bans.stream().anyMatch(indefiniteBan -> indefiniteBan.getUsernames().contains(username)); return bans.stream().anyMatch(indefiniteBan -> indefiniteBan.getUsernames().contains(username));
} }
return this.indefiniteBans.stream().anyMatch(indefiniteBan -> indefiniteBan.getUsernames().contains(username)); return this.indefiniteBans.stream().anyMatch(indefiniteBan -> indefiniteBan.getUsernames().contains(username));

4
src/main/java/dev/plex/services/impl/UpdateCheckerService.java
View File

@ -4,13 +4,13 @@ import dev.plex.services.AbstractService;
public class UpdateCheckerService extends AbstractService public class UpdateCheckerService extends AbstractService
{ {
private boolean newVersion = false;
public UpdateCheckerService() public UpdateCheckerService()
{ {
super(true, true); super(true, true);
} }
private boolean newVersion = false;
@Override @Override
public void run() public void run()
{ {

1
src/main/java/dev/plex/storage/MongoConnection.java
View File

@ -5,7 +5,6 @@ import com.mongodb.client.MongoClients;
import dev.morphia.Datastore; import dev.morphia.Datastore;
import dev.morphia.Morphia; import dev.morphia.Morphia;
import dev.morphia.mapping.MapperOptions; import dev.morphia.mapping.MapperOptions;
import dev.plex.Plex;
import dev.plex.PlexBase; import dev.plex.PlexBase;
import dev.plex.player.PlexPlayer; import dev.plex.player.PlexPlayer;

3
src/main/java/dev/plex/storage/RedisConnection.java
View File

@ -2,9 +2,8 @@ package dev.plex.storage;
import dev.plex.PlexBase; import dev.plex.PlexBase;
import dev.plex.util.PlexLog; import dev.plex.util.PlexLog;
import redis.clients.jedis.Jedis;
import java.util.function.Consumer; import java.util.function.Consumer;
import redis.clients.jedis.Jedis;
public class RedisConnection extends PlexBase public class RedisConnection extends PlexBase
{ {