68 Commits

Author SHA1 Message Date
eb788f02dd Plex v1.0.1 2022-04-12 21:22:50 -05:00
096bb1bb24 Reformat 2022-04-12 21:22:17 -05:00
223eaf30b3 Code review 2022-04-12 21:20:56 -05:00
6763878d74 Readd code style 2022-04-12 21:10:41 -05:00
81c656c86e Tell admins if a player has notes 2022-04-12 21:08:12 -05:00
6c09905a8d Update build.gradle 2022-04-12 16:38:19 -05:00
f0c646688e Speed things up 2022-04-11 21:51:17 -05:00
336f17b1cf refactor packages and rename + add sql permission system + mongodb 2022-04-11 10:56:26 -07:00
583f502cee Merge remote-tracking branch 'origin/master' 2022-04-11 00:53:49 -07:00
c071195aaf fix punishments not being retrieved from sql 2022-04-11 00:53:09 -07:00
f62b084bbc Update settings.gradle 2022-04-11 00:17:13 -05:00
c92a4bbdb9 add jitpack for vault 2022-04-10 17:27:03 -07:00
9b0b7537c2 fix build.gradle publishing wrong artifact 2022-04-10 17:22:22 -07:00
f8d25491d5 add library dependencies to pom 2022-04-10 16:36:37 -07:00
1dc0e05715 Closes #26 2022-04-10 18:30:21 -05:00
ffe8993ee1 use packs's repository for plugin-yml 2022-04-10 15:39:58 -07:00
90ef0a2121 Merge branch 'master' of https://github.com/plexusorg/plex into taah-cmd-blocker 2022-04-10 15:30:23 -07:00
7457e9e454 wack 2022-04-10 17:27:46 -05:00
dc65187381 add /csay
make /say and /csay not parse minimessage messages
add a strip color function to strip a message of minimessage strings
2022-04-10 15:27:25 -07:00
b449d732b0 Merge branch 'master' of https://github.com/plexusorg/plex into taah-cmd-blocker
 Conflicts:
	src/main/java/dev/plex/command/blocker/CommandBlockerManager.java
	src/main/java/dev/plex/listener/impl/CommandListener.java
	src/main/resources/commands.yml
2022-04-10 15:03:32 -07:00
8dfaaf7a8c fix /tag
fix /notes
fix /rank
switch /admin to a datautils check instead of using ashcon api
2022-04-10 15:02:50 -07:00
6b7bfacbfd Update EntityWipeCMD.java 2022-04-10 17:01:02 -05:00
16186bdfbb Merge pull request #27 from ayunami2000/master
fix entitywipe not actually wiping entities
2022-04-10 17:00:18 -05:00
4bbb73d1ff Merge branch 'plexusorg:master' into master 2022-04-10 17:57:13 -04:00
aa9f306586 fix entitywipe not actually wiping entities 2022-04-10 17:56:15 -04:00
08a004d65f Merge pull request #22 from ayunami2000/master
cleanup & fix
2022-04-10 16:16:23 -05:00
d798904394 Update Plex.java 2022-04-10 13:33:49 -05:00
f78edc55d4 re remove debug logging
lmao
2022-04-10 14:23:34 -04:00
8866f44aa2 fix issue where matcher would match partial commands 2022-04-10 14:21:34 -04:00
0fc2aa68b0 remove separated color 2022-04-10 14:10:15 -04:00
391677596a i forgor 💀 2022-04-10 13:45:52 -04:00
5988eba06b cleanup & fix 2022-04-10 13:44:36 -04:00
81d3cc8dde add additional conditions for telnet users 2022-04-10 02:31:07 -07:00
7b13ca0248 update to gradle 7.4.2 and host a custom fork of the mincrell plugin for now 2022-04-10 01:32:33 -07:00
06fcf531af instead of checking if a command starts with the message, check if each argument of the command is equal to the message until you can't check anymore 2022-04-10 00:42:53 -07:00
9f7ac310d9 merge master branch and add ayunami's delimiter code, with of course, credit to him added in the code, and fix a bug 2022-04-10 00:25:14 -07:00
09bc47f3fb Merge branch 'master' into taah-cmd-blocker
# Conflicts:
#	src/main/java/dev/plex/Plex.java
#	src/main/java/dev/plex/listener/impl/CommandListener.java
#	src/main/java/dev/plex/services/impl/CommandBlockerService.java
#	src/main/resources/commands.yml
2022-04-10 00:04:06 -07:00
8544775be2 Delete build.properties 2022-04-10 01:56:05 -05:00
c8c8fc9c59 WTF 2022-04-10 01:55:20 -05:00
14095fdebb jkn 2022-04-10 01:54:55 -05:00
dcecebdc8d Revert API 2022-04-10 01:47:33 -05:00
f73c63f1e7 test 2022-04-10 00:46:17 -05:00
067094130f Lets try this again 2022-04-10 00:12:44 -05:00
d16aa6de4c Merge remote-tracking branch 'origin/master'
# Conflicts:
#	Plex-Core/src/main/java/dev/plex/command/impl/SayCMD.java
2022-04-09 22:11:06 -07:00
6086f761eb add /say
fix /tag
2022-04-09 22:10:35 -07:00
b2f1f7e055 Remove ignored files 2022-04-10 00:01:46 -05:00
3c20213c0d oh boy 2022-04-10 00:01:15 -05:00
3500cae2da Oops lol 2022-04-09 23:58:03 -05:00
c4be024619 Merge branch 'master' of https://github.com/plexusorg/Plex 2022-04-09 23:51:29 -05:00
9849003ecc API 👀 2022-04-09 23:51:27 -05:00
f274e20f84 sanitize minimessage + strip legacy colors 2022-04-09 23:24:44 -04:00
f180eec44a "OOPS!!" 2022-04-09 21:54:34 -04:00
b1ef89dae9 fix bug 2022-04-09 21:53:27 -04:00
de20747d45 Merge branch 'master' of https://github.com/plexusorg/Plex 2022-04-09 17:14:26 -04:00
c801feed6f fix special cases such as worldedit
all my homies hate worldedit
2022-04-09 17:13:47 -04:00
5fdc5826b7 Update README.md 2022-04-09 16:08:20 -05:00
a87a9241af optimize command blocker 2022-04-09 15:31:55 -04:00
8fb64b8499 :broh: 2022-04-09 00:27:49 -05:00
10dd546c09 Quick fix 2022-04-09 00:26:34 -05:00
5a352b2ca0 Set the jar name just to "Plex" 2022-04-09 00:14:36 -05:00
333f38fb64 Don't send empty line for list if there are no players 2022-04-09 00:09:54 -05:00
d55eaf0d3d A few more 2022-04-09 00:08:18 -05:00
e35d70bc3c Change config entries 2022-04-09 00:08:03 -05:00
e421867f63 Bump to snapshot 2022-04-09 00:05:06 -05:00
ec7d814467 Merge branch 'master' of https://github.com/plexusorg/Plex into taah-cmd-blocker 2022-04-08 18:56:57 -05:00
9c5a557316 switch statements look cleaner here 2022-04-08 00:32:53 -07:00
38e79fd917 add case insensitivity 2022-04-08 00:24:46 -07:00
10e63f5e86 - taah command blocker 2022-04-08 00:20:17 -07:00
80 changed files with 1004 additions and 551 deletions

3
.gitignore vendored
View File

@ -1,8 +1,7 @@
/.idea/
/.idea/codeStyles/codeStyleConfig.xml
*.iml
/target/
/src/main/resources/build.properties
src/main/resources/build.properties
# OS
.DS_Store

2
Jenkinsfile vendored
View File

@ -23,7 +23,7 @@ pipeline {
}
post {
always {
archiveArtifacts artifacts: "build/libs/*.jar", fingerprint: true
archiveArtifacts artifacts: "build/libs/Plex.jar", fingerprint: true
javadoc javadocDir: "build/docs/javadoc", keepAll: false
discordSend description: "**Build:** ${env.BUILD_NUMBER}\n**Status:** ${currentBuild.currentResult}", enableArtifactsList: true, footer: "Built with Jenkins", link: env.BUILD_URL, result: currentBuild.currentResult, scmWebUrl: "https://github.com/plexusorg/Plex", showChangeset: true, title: env.JOB_NAME, webhookURL: env.PLEX_WEBHOOK_URL
cleanWs()

View File

@ -1,3 +1,8 @@
# Plex
# Plex [![Build Status](https://ci.plex.us.org/job/Plex/job/master/badge/icon)](https://ci.plex.us.org/job/Plex/job/master/)
A new freedom plugin.
Plex is a new freedom plugin. It is an alternative to TotalFreedomMod. It has many of the features that make a freedom
server unique, but also many features that TotalFreedomMod doesnt have. For example, there is full support for using a
permissions plugin instead of ranks. It is also much more performance oriented. You can use Redis to store indefinite
bans and store player data in MongoDB, MariaDB, or SQLite. Plex is also fully customizable as you can change almost all
of the messages within the plugin. Plex also has a module system which can be used to add additional functionality. Plex
is not a rewrite, "debloat", or related to TotalFreedomMod. Plex is an entirely new experience.

View File

@ -1,7 +1,7 @@
plugins {
id "java"
id "maven-publish"
id "net.minecrell.plugin-yml.bukkit" version "0.5.1"
id "net.minecrell.plugin-yml.bukkit" version "0.6.1-SNAPSHOT"
id "com.github.johnrengelman.shadow" version "7.1.2"
}
@ -19,6 +19,13 @@ repositories {
url = uri("https://repo.maven.apache.org/maven2/")
}
maven {
url = uri("https://jitpack.io")
content {
includeGroup("com.github.MilkBowl")
}
}
mavenCentral()
}
@ -43,19 +50,30 @@ dependencies {
library "org.eclipse.jetty:jetty-proxy:11.0.9"
library "com.google.code.gson:gson:2.9.0"
compileOnly "io.papermc.paper:paper-api:1.18.2-R0.1-SNAPSHOT"
compileOnly("com.github.MilkBowl:VaultAPI:1.7") {
exclude group: "org.bukkit", module: "bukkit"
}
implementation "org.bstats:bstats-base:3.0.0"
implementation "org.bstats:bstats-bukkit:3.0.0"
}
group = "dev.plex"
version = "1.0"
version = "1.0.1"
description = "Plex"
shadowJar {
archiveBaseName.set("Plex")
archiveClassifier.set("")
archiveVersion.set("")
relocate "org.bstats", "dev.plex"
}
tasks.jar {
archiveBaseName.set("Plex")
archiveClassifier.set("notshaded")
archiveVersion.set("")
}
bukkit {
name = "Plex"
version = rootProject.version
@ -63,6 +81,7 @@ bukkit {
main = "dev.plex.Plex"
website = "https://plex.us.org"
authors = ["Telesphoreo", "taahanis", "super"]
softDepend = ["Vault"]
apiVersion = "1.18"
}
@ -95,7 +114,7 @@ String getBuildNumber() {
}
static def getDate() {
return new Date().format("MM/dd/yyyy '<light_purple>at<gold>' hh:mm:ss a")
return new Date().format("MM/dd/yyyy '<light_purple>at<gold>' hh:mm:ss a z")
}
task buildProperties {
@ -114,7 +133,26 @@ java {
publishing {
publications {
maven(MavenPublication) {
from(components.java)
pom.withXml {
def dependenciesNode = asNode().appendNode("dependencies")
configurations.getByName("library").getAllDependencies().each { dependency ->
dependenciesNode.appendNode("dependency").with {
it.appendNode("groupId", dependency.group)
it.appendNode("artifactId", dependency.name)
it.appendNode("version", dependency.version)
it.appendNode("scope", "provided")
}
}
configurations.getByName("implementation").getAllDependencies().each { dependency ->
dependenciesNode.appendNode("dependency").with {
it.appendNode("groupId", dependency.group)
it.appendNode("artifactId", dependency.name)
it.appendNode("version", dependency.version)
it.appendNode("scope", "runtime")
}
}
}
artifacts = [shadowJar]
}
}
repositories {

View File

@ -1,5 +1,5 @@
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-7.3.3-bin.zip
distributionUrl=https\://services.gradle.org/distributions/gradle-7.4.2-bin.zip
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists

View File

@ -1 +1,7 @@
rootProject.name = 'Plex'
pluginManagement {
repositories {
maven { url = uri("https://nexus.telesphoreo.me/repository/gradle-plugins/") }
gradlePluginPortal()
}
}
rootProject.name = "Plex"

View File

@ -3,12 +3,7 @@ package dev.plex;
import dev.plex.admin.Admin;
import dev.plex.admin.AdminList;
import dev.plex.cache.DataUtils;
import dev.plex.cache.player.MongoPlayerData;
import dev.plex.cache.player.PlayerCache;
import dev.plex.cache.player.SQLPlayerData;
import dev.plex.cache.sql.SQLNotes;
import dev.plex.cache.sql.SQLPunishment;
import dev.plex.command.blocker.CommandBlockerManager;
import dev.plex.cache.PlayerCache;
import dev.plex.config.Config;
import dev.plex.handlers.CommandHandler;
import dev.plex.handlers.ListenerHandler;
@ -21,19 +16,25 @@ import dev.plex.storage.MongoConnection;
import dev.plex.storage.RedisConnection;
import dev.plex.storage.SQLConnection;
import dev.plex.storage.StorageType;
import dev.plex.storage.permission.SQLPermissions;
import dev.plex.storage.player.MongoPlayerData;
import dev.plex.storage.player.SQLPlayerData;
import dev.plex.storage.punishment.SQLNotes;
import dev.plex.storage.punishment.SQLPunishment;
import dev.plex.util.PlexLog;
import dev.plex.util.PlexUtils;
import dev.plex.util.UpdateChecker;
import dev.plex.world.CustomWorld;
import lombok.Getter;
import lombok.Setter;
import org.bstats.bukkit.Metrics;
import org.bukkit.Bukkit;
import org.bukkit.plugin.java.JavaPlugin;
import java.io.File;
import java.io.InputStream;
import java.util.Properties;
import lombok.Getter;
import lombok.Setter;
import net.milkbowl.vault.permission.Permission;
import org.bstats.bukkit.Metrics;
import org.bukkit.Bukkit;
import org.bukkit.plugin.RegisteredServiceProvider;
import org.bukkit.plugin.java.JavaPlugin;
@Getter
@Setter
@ -45,7 +46,7 @@ public class Plex extends JavaPlugin
public Config config;
public Config messages;
public Config indefBans;
public Config blockedCommands;
public Config commands;
public File modulesFolder;
private StorageType storageType = StorageType.SQLITE;
@ -59,17 +60,19 @@ public class Plex extends JavaPlugin
private SQLPunishment sqlPunishment;
private SQLNotes sqlNotes;
private SQLPermissions sqlPermissions;
private ModuleManager moduleManager;
private RankManager rankManager;
private ServiceManager serviceManager;
private PunishmentManager punishmentManager;
private CommandBlockerManager commandBlockerManager;
private AdminList adminList;
private UpdateChecker updateChecker;
private String system;
private Permission permissions;
public static Plex get()
{
return plugin;
@ -82,7 +85,7 @@ public class Plex extends JavaPlugin
config = new Config(this, "config.yml");
messages = new Config(this, "messages.yml");
indefBans = new Config(this, "indefbans.yml");
blockedCommands = new Config(this, "commands.yml");
commands = new Config(this, "commands.yml");
build.load(this);
modulesFolder = new File(this.getDataFolder() + File.separator + "modules");
@ -103,7 +106,7 @@ public class Plex extends JavaPlugin
messages.load();
// Don't add default entries to indefinite ban file
indefBans.load(false);
blockedCommands.load();
commands.load(false);
sqlConnection = new SQLConnection();
mongoConnection = new MongoConnection();
@ -118,12 +121,18 @@ public class Plex extends JavaPlugin
{
PlexUtils.testConnections();
PlexLog.log("Connected to " + storageType.name().toUpperCase());
} catch (Exception e)
}
catch (Exception e)
{
PlexLog.error("Failed to connect to " + storageType.name().toUpperCase());
e.printStackTrace();
}
if (!setupPermissions() && system.equalsIgnoreCase("permissions") && !getServer().getPluginManager().isPluginEnabled("Vault"))
{
throw new RuntimeException("Vault is required to run on the server if you use permissions!");
}
updateChecker = new UpdateChecker();
PlexLog.log("Update checking enabled");
@ -135,7 +144,8 @@ public class Plex extends JavaPlugin
{
redisConnection.getJedis();
PlexLog.log("Connected to Redis!");
} else
}
else
{
PlexLog.log("Redis is disabled in the configuration file, not connecting.");
}
@ -143,11 +153,13 @@ public class Plex extends JavaPlugin
if (storageType == StorageType.MONGODB)
{
mongoPlayerData = new MongoPlayerData();
} else
}
else
{
sqlPlayerData = new SQLPlayerData();
sqlPunishment = new SQLPunishment();
sqlNotes = new SQLNotes();
sqlPermissions = new SQLPermissions();
}
new ListenerHandler();
@ -163,9 +175,6 @@ public class Plex extends JavaPlugin
punishmentManager.mergeIndefiniteBans();
PlexLog.log("Punishment System initialized");
commandBlockerManager = new CommandBlockerManager();
PlexLog.log("Command Blocker initialized");
generateWorlds();
serviceManager = new ServiceManager();
@ -191,7 +200,8 @@ public class Plex extends JavaPlugin
if (mongoPlayerData != null) //back to mongo checking
{
mongoPlayerData.update(plexPlayer); //update the player's document
} else if (sqlPlayerData != null) //sql checking
}
else if (sqlPlayerData != null) //sql checking
{
sqlPlayerData.update(plexPlayer);
}
@ -254,10 +264,18 @@ public class Plex extends JavaPlugin
author = props.getProperty("buildAuthor", "unknown");
date = props.getProperty("buildDate", "unknown");
head = props.getProperty("buildHead", "unknown");
} catch (Exception ex)
}
catch (Exception ex)
{
PlexLog.error("Could not load build properties! Did you compile with NetBeans/Maven?");
}
}
}
public boolean setupPermissions()
{
RegisteredServiceProvider<Permission> rsp = Bukkit.getServicesManager().getRegistration(Permission.class);
permissions = rsp.getProvider();
return permissions != null;
}
}

View File

@ -54,7 +54,7 @@ public class AdminList extends PlexBase
}
/**
* Gathers every admin's username (cached and in the database)
* Gathers every admins username (cached and in the database)
*
* @return An array list of the names of every admin
*/

View File

@ -1,11 +1,9 @@
package dev.plex.cache;
import dev.plex.Plex;
import dev.plex.cache.player.PlayerCache;
import dev.plex.player.PlexPlayer;
import dev.plex.storage.StorageType;
import java.util.UUID;
import org.bukkit.Bukkit;
/**
* Parent cache class
@ -30,6 +28,18 @@ public class DataUtils
}
}
public static boolean hasPlayedBefore(String username)
{
if (Plex.get().getStorageType() == StorageType.MONGODB)
{
return Plex.get().getMongoPlayerData().exists(username);
}
else
{
return Plex.get().getSqlPlayerData().exists(username);
}
}
/**
* Gets a player from cache or from the database
*

View File

@ -1,4 +1,4 @@
package dev.plex.cache.player;
package dev.plex.cache;
import com.google.common.collect.Maps;
import dev.plex.player.PlexPlayer;

View File

@ -1,44 +0,0 @@
package dev.plex.cache.notes;
import com.google.common.reflect.TypeToken;
import com.google.gson.Gson;
import dev.plex.Plex;
import dev.plex.cache.player.PlayerCache;
import dev.plex.player.PlexPlayer;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.UUID;
public class PlayerNotes
{
private final String SELECT = "SELECT * FROM `notes` WHERE uuid=?";
//private final String UPDATE = "UPDATE `notes` SET name=?, written_by=?, note=? WHERE uuid=?";
private final String INSERT = "INSERT INTO `notes` (`uuid`, `name`, `written_by`, `note`) VALUES (?, ?, ?, ?);";
public PlexPlayer getByUUID(UUID uuid)
{
try (Connection con = Plex.get().getSqlConnection().getCon())
{
PreparedStatement statement = con.prepareStatement(SELECT);
statement.setString(1, uuid.toString());
ResultSet set = statement.executeQuery();
PlexPlayer plexPlayer = new PlexPlayer(uuid);
while (set.next())
{
String name = set.getString("name");
String writtenBy = set.getString("written_by");
String note = set.getString("note");
}
return plexPlayer;
}
catch (SQLException throwables)
{
throwables.printStackTrace();
}
return null;
}
}

View File

@ -2,31 +2,37 @@ package dev.plex.command;
import dev.plex.Plex;
import dev.plex.cache.DataUtils;
import dev.plex.cache.player.PlayerCache;
import dev.plex.cache.PlayerCache;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
import dev.plex.command.exception.*;
import dev.plex.command.exception.CommandFailException;
import dev.plex.command.exception.ConsoleMustDefinePlayerException;
import dev.plex.command.exception.ConsoleOnlyException;
import dev.plex.command.exception.PlayerNotBannedException;
import dev.plex.command.exception.PlayerNotFoundException;
import dev.plex.command.source.RequiredCommandSource;
import dev.plex.player.PlexPlayer;
import dev.plex.rank.enums.Rank;
import dev.plex.util.PlexLog;
import dev.plex.util.PlexUtils;
import java.util.Arrays;
import java.util.UUID;
import net.kyori.adventure.audience.Audience;
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.serializer.legacy.LegacyComponentSerializer;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.World;
import org.bukkit.command.*;
import org.bukkit.command.Command;
import org.bukkit.command.CommandMap;
import org.bukkit.command.CommandSender;
import org.bukkit.command.ConsoleCommandSender;
import org.bukkit.command.PluginIdentifiableCommand;
import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.Arrays;
import java.util.UUID;
/**
* Superclass for all commands
*/
@ -125,7 +131,8 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
{
send(sender, messageComponent("noPermissionRank", ChatColor.stripColor(getLevel().getLoginMessage())));
return true;
} else
}
else
{
if (getLevel().isAtLeast(Rank.ADMIN) && !plexPlayer.isAdminActive())
{
@ -133,14 +140,52 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
return true;
}
}
} else if (plugin.getSystem().equalsIgnoreCase("permissions"))
}
else if (plugin.getSystem().equalsIgnoreCase("permissions"))
{
if (!player.hasPermission(perms.permission()))
{
send(sender, messageComponent("noPermissionNode", perms.permission()));
return true;
}
} else
}
else
{
PlexLog.error("Neither permissions or ranks were selected to be used in the configuration file!");
send(sender, "There is a server misconfiguration. Please alert a developer or the owner");
return true;
}
}
if (sender instanceof ConsoleCommandSender && !sender.getName().equalsIgnoreCase("console")) //telnet
{
PlexPlayer plexPlayer = DataUtils.getPlayer(sender.getName());
if (plugin.getSystem().equalsIgnoreCase("ranks"))
{
if (!plexPlayer.getRankFromString().isAtLeast(getLevel()))
{
send(sender, messageComponent("noPermissionRank", ChatColor.stripColor(getLevel().getLoginMessage())));
return true;
}
else
{
if (getLevel().isAtLeast(Rank.ADMIN) && !plexPlayer.isAdminActive())
{
send(sender, messageComponent("noPermissionRank", ChatColor.stripColor(getLevel().getLoginMessage())));
return true;
}
}
}
else if (plugin.getSystem().equalsIgnoreCase("permissions"))
{
if (!plugin.getPermissions().playerHas(null, Bukkit.getOfflinePlayer(plexPlayer.getUuid()), perms.permission()))
{
send(sender, messageComponent("noPermissionNode", perms.permission()));
return true;
}
}
else
{
PlexLog.error("Neither permissions or ranks were selected to be used in the configuration file!");
send(sender, "There is a server misconfiguration. Please alert a developer or the owner");
@ -154,9 +199,11 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
{
send(sender, component);
}
} catch (PlayerNotFoundException | CommandFailException | ConsoleOnlyException | ConsoleMustDefinePlayerException | PlayerNotBannedException ex)
}
catch (PlayerNotFoundException | CommandFailException | ConsoleOnlyException |
ConsoleMustDefinePlayerException | PlayerNotBannedException ex)
{
send(sender, MiniMessage.miniMessage().deserialize(ex.getMessage()));
send(sender, PlexUtils.mmDeserialize(ex.getMessage()));
}
return true;
}
@ -178,7 +225,8 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
return true;
}
}
} else if (params.aliases().split(",").length < 1)
}
else if (params.aliases().split(",").length < 1)
{
return getName().equalsIgnoreCase(label);
}
@ -234,6 +282,28 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
{
return checkRank((Player)sender, rank, permission);
}
if (!sender.getName().equalsIgnoreCase("console"))
{
PlexPlayer plexPlayer = DataUtils.getPlayer(sender.getName());
if (plugin.getSystem().equalsIgnoreCase("ranks"))
{
if (!plexPlayer.getRankFromString().isAtLeast(rank))
{
throw new CommandFailException(PlexUtils.messageString("noPermissionRank", ChatColor.stripColor(rank.getLoginMessage())));
}
if (rank.isAtLeast(Rank.ADMIN) && !plexPlayer.isAdminActive())
{
throw new CommandFailException(PlexUtils.messageString("noPermissionRank", ChatColor.stripColor(rank.getLoginMessage())));
}
}
else if (plugin.getSystem().equalsIgnoreCase("permissions"))
{
if (!plugin.getPermissions().playerHas(null, Bukkit.getOfflinePlayer(plexPlayer.getUuid()), permission))
{
throw new CommandFailException(PlexUtils.messageString("noPermissionNode", permission));
}
}
}
return true;
}
@ -263,7 +333,8 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
{
throw new CommandFailException(PlexUtils.messageString("noPermissionRank", ChatColor.stripColor(rank.getLoginMessage())));
}
} else if (plugin.getSystem().equalsIgnoreCase("permissions"))
}
else if (plugin.getSystem().equalsIgnoreCase("permissions"))
{
if (!player.hasPermission(permission))
{
@ -283,7 +354,8 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
if (plugin.getSystem().equalsIgnoreCase("ranks"))
{
return rank.isAtLeast(Rank.ADMIN) ? plexPlayer.isAdminActive() && plexPlayer.getRankFromString().isAtLeast(rank) : plexPlayer.getRankFromString().isAtLeast(rank);
} else if (plugin.getSystem().equalsIgnoreCase("permissions"))
}
else if (plugin.getSystem().equalsIgnoreCase("permissions"))
{
return player.hasPermission(permission);
}
@ -323,7 +395,8 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
if (plugin.getSystem().equalsIgnoreCase("ranks"))
{
return rank.isAtLeast(Rank.ADMIN) ? plexPlayer.isAdminActive() && plexPlayer.getRankFromString().isAtLeast(rank) : plexPlayer.getRankFromString().isAtLeast(rank);
} else if (plugin.getSystem().equalsIgnoreCase("permissions"))
}
else if (plugin.getSystem().equalsIgnoreCase("permissions"))
{
return player.hasPermission(permission);
}
@ -536,7 +609,7 @@ public abstract class PlexCommand extends Command implements PluginIdentifiableC
*/
protected Component mmString(String s)
{
return MiniMessage.miniMessage().deserialize(s);
return PlexUtils.mmDeserialize(s);
}
public Rank getLevel()

View File

@ -1,22 +0,0 @@
package dev.plex.command.blocker;
import dev.plex.rank.enums.Rank;
import lombok.Getter;
@Getter
public class BaseCommand
{
private final Rank rank;
private final String message;
public BaseCommand(Rank r, String m)
{
rank = r;
message = m;
}
public String toString()
{
return "BaseCommand (Rank: " + (rank == null ? "ALL" : rank.name()) + ", Message: " + message + ")";
}
}

View File

@ -1,108 +0,0 @@
package dev.plex.command.blocker;
import dev.plex.Plex;
import dev.plex.PlexBase;
import dev.plex.rank.enums.Rank;
import dev.plex.util.PlexLog;
import dev.plex.util.PlexUtils;
import lombok.Getter;
import org.bukkit.Bukkit;
import org.bukkit.command.Command;
import org.bukkit.command.PluginCommand;
import org.bukkit.command.PluginCommandYamlParser;
import org.bukkit.plugin.Plugin;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.regex.Pattern;
@Getter
public class CommandBlockerManager extends PlexBase
{
private List<BaseCommand> blockedCommands = new ArrayList<>();
public boolean loadedYet;
public void syncCommands()
{
loadedYet = false;
blockedCommands.clear();
List<String> raw = plugin.blockedCommands.getStringList("blockedCommands");
for (String cmd : raw)
{
int lastDelim = cmd.lastIndexOf(':');
String cmdWithoutMsg = cmd.substring(0, lastDelim);
String[] rawPieces = cmdWithoutMsg.split(":", 3);
String rawType = rawPieces[0].toLowerCase();
String rawRank = rawPieces[1].toLowerCase();
String regexOrMatch = rawPieces[2];
String message = cmd.substring(lastDelim + 1);
if (message.equals("_"))
{
message = PlexUtils.messageString("commandBlocked");
}
Rank rank = switch (rawRank)
{
case "e" -> null;
case "a" -> Rank.ADMIN;
case "s" -> Rank.SENIOR_ADMIN;
default -> null;
};
if (rawType.equals("r"))
{
blockedCommands.add(new RegexCommand(Pattern.compile(regexOrMatch, Pattern.CASE_INSENSITIVE), rank, message));
}
else if (rawType.equals("m"))
{
int ind = regexOrMatch.indexOf(' ');
if (ind == -1 && regexOrMatch.endsWith(":"))
{
String pluginName = regexOrMatch.substring(0, regexOrMatch.length() - 1);
Plugin plugin = Arrays.stream(Bukkit.getServer().getPluginManager().getPlugins()).filter(pl -> pl.getName().equalsIgnoreCase(pluginName)).findAny().orElse(null);
if (plugin != null)
{
List<Command> commandList = PluginCommandYamlParser.parse(plugin);
for (Command command : commandList)
{
blockedCommands.add(new MatchCommand(command.getName(), rank, message));
blockedCommands.add(new MatchCommand(pluginName + ":" + command.getName(), rank, message));
for (String alias : command.getAliases())
{
blockedCommands.add(new MatchCommand(alias, rank, message));
blockedCommands.add(new MatchCommand(pluginName + ":" + alias, rank, message));
}
}
}
}
String blockedArgs = ind == -1 ? "" : regexOrMatch.substring(ind + 1);
if (!blockedArgs.isEmpty())
{
blockedArgs = " " + blockedArgs; // necessary in case no args
}
PluginCommand pluginCommand = Plex.get().getServer().getPluginCommand(ind == -1 ? regexOrMatch : regexOrMatch.substring(0, ind));
if (pluginCommand != null)
{
String pluginName = pluginCommand.getPlugin().getName();
blockedCommands.add(new MatchCommand(pluginCommand.getName() + blockedArgs, rank, message));
blockedCommands.add(new MatchCommand(pluginName + ":" + pluginCommand.getName() + blockedArgs, rank, message));
List<String> aliases = pluginCommand.getAliases();
for (String alias : aliases)
{
blockedCommands.add(new MatchCommand(alias + blockedArgs, rank, message));
blockedCommands.add(new MatchCommand(pluginName + ":" + alias + blockedArgs, rank, message));
}
}
}
}
loadedYet = true;
}
}

View File

@ -1,21 +0,0 @@
package dev.plex.command.blocker;
import dev.plex.rank.enums.Rank;
import lombok.Getter;
@Getter
public class MatchCommand extends BaseCommand
{
private final String match;
public MatchCommand(String r1, Rank r2, String m1)
{
super(r2, m1);
match = r1;
}
public String toString()
{
return "MatchCommand (Rank: " + (getRank() == null ? "ALL" : getRank().name()) + ", Match: " + match + ", Message: " + getMessage() + ")";
}
}

View File

@ -1,23 +0,0 @@
package dev.plex.command.blocker;
import dev.plex.rank.enums.Rank;
import lombok.Getter;
import java.util.regex.Pattern;
@Getter
public class RegexCommand extends BaseCommand
{
private final Pattern regex;
public RegexCommand(Pattern r1, Rank r2, String m1)
{
super(r2, m1);
regex = r1;
}
public String toString()
{
return "RegexCommand (Rank: " + (getRank() == null ? "ALL" : getRank().name()) + ", Regex: " + regex.toString() + ", Message: " + getMessage() + ")";
}
}

View File

@ -0,0 +1,16 @@
package dev.plex.command.blocking;
import com.google.common.collect.Lists;
import java.util.List;
import lombok.Data;
import net.kyori.adventure.text.Component;
@Data
public class BlockedCommand
{
private Component message;
private String requiredLevel;
private String regex;
private String command;
private List<String> commandAliases = Lists.newArrayList();
}

View File

@ -14,11 +14,9 @@ import dev.plex.event.AdminRemoveEvent;
import dev.plex.event.AdminSetRankEvent;
import dev.plex.player.PlexPlayer;
import dev.plex.rank.enums.Rank;
import dev.plex.util.PlexLog;
import dev.plex.util.PlexUtils;
import java.util.Arrays;
import java.util.List;
import java.util.UUID;
import net.kyori.adventure.text.Component;
import org.apache.commons.lang.StringUtils;
import org.bukkit.Bukkit;
@ -54,18 +52,18 @@ public class AdminCMD extends PlexCommand
throw new ConsoleOnlyException();
}
UUID targetUUID = PlexUtils.getFromName(args[1]);
/*UUID targetUUID = PlexUtils.getFromName(args[1]);
if (targetUUID != null)
{
PlexLog.debug("Admin Adding UUID: " + targetUUID);
}
}*/
if (targetUUID == null || !DataUtils.hasPlayedBefore(targetUUID))
if (!DataUtils.hasPlayedBefore(args[1]))
{
throw new PlayerNotFoundException();
}
PlexPlayer plexPlayer = DataUtils.getPlayer(targetUUID);
PlexPlayer plexPlayer = DataUtils.getPlayer(args[1]);
if (isAdmin(plexPlayer))
{
@ -87,13 +85,13 @@ public class AdminCMD extends PlexCommand
throw new ConsoleOnlyException();
}
UUID targetUUID = PlexUtils.getFromName(args[1]);
// UUID targetUUID = PlexUtils.getFromName(args[1]);
if (targetUUID == null || !DataUtils.hasPlayedBefore(targetUUID))
if (!DataUtils.hasPlayedBefore(args[1]))
{
throw new PlayerNotFoundException();
}
PlexPlayer plexPlayer = DataUtils.getPlayer(targetUUID);
PlexPlayer plexPlayer = DataUtils.getPlayer(args[1]);
if (!isAdmin(plexPlayer))
{
@ -116,9 +114,9 @@ public class AdminCMD extends PlexCommand
throw new ConsoleOnlyException();
}
UUID targetUUID = PlexUtils.getFromName(args[1]);
// UUID targetUUID = PlexUtils.getFromName(args[1]);
if (targetUUID == null || !DataUtils.hasPlayedBefore(targetUUID))
if (!DataUtils.hasPlayedBefore(args[1]))
{
throw new PlayerNotFoundException();
}
@ -135,7 +133,7 @@ public class AdminCMD extends PlexCommand
return messageComponent("rankMustBeHigherThanAdmin");
}
PlexPlayer plexPlayer = DataUtils.getPlayer(targetUUID);
PlexPlayer plexPlayer = DataUtils.getPlayer(args[1]);
if (!isAdmin(plexPlayer))
{

View File

@ -1,6 +1,6 @@
package dev.plex.command.impl;
import dev.plex.cache.player.PlayerCache;
import dev.plex.cache.PlayerCache;
import dev.plex.command.PlexCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;

View File

@ -47,6 +47,8 @@ public class BanCMD extends PlexCommand
PlexPlayer plexPlayer = DataUtils.getPlayer(targetUUID);
Player player = Bukkit.getPlayer(targetUUID);
if (plugin.getSystem().equalsIgnoreCase("ranks"))
{
if (isAdmin(plexPlayer))
{
if (!isConsole(sender))
@ -59,6 +61,7 @@ public class BanCMD extends PlexCommand
}
}
}
}
plugin.getPunishmentManager().isAsyncBanned(targetUUID).whenComplete((aBoolean, throwable) ->
{

View File

@ -7,9 +7,7 @@ import dev.plex.command.annotation.CommandPermissions;
import dev.plex.command.source.RequiredCommandSource;
import dev.plex.player.PlexPlayer;
import dev.plex.rank.enums.Rank;
import dev.plex.util.PlexUtils;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.format.NamedTextColor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull;

View File

@ -0,0 +1,31 @@
package dev.plex.command.impl;
import dev.plex.command.PlexCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
import dev.plex.command.source.RequiredCommandSource;
import dev.plex.rank.enums.Rank;
import dev.plex.util.PlexUtils;
import net.kyori.adventure.text.Component;
import org.apache.commons.lang.StringUtils;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@CommandPermissions(level = Rank.ADMIN, permission = "plex.consolesay", source = RequiredCommandSource.CONSOLE)
@CommandParameters(name = "consolesay", usage = "/<command> <message>", description = "Displays a message to everyone", aliases = "csay")
public class ConsoleSayCommand extends PlexCommand
{
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{
if (args.length == 0)
{
return usage();
}
PlexUtils.broadcast(PlexUtils.messageComponent("consoleSayMessage", sender.getName(), PlexUtils.mmStripColor(StringUtils.join(args, " "))));
return null;
}
}

View File

@ -8,18 +8,20 @@ import dev.plex.command.annotation.System;
import dev.plex.rank.enums.Rank;
import dev.plex.util.PlexLog;
import dev.plex.util.PlexUtils;
import java.util.Arrays;
import java.util.List;
import java.util.Locale;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.format.NamedTextColor;
import org.bukkit.Bukkit;
import org.bukkit.World;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@CommandParameters(name = "pdebug", description = "Plex's debug command", usage = "/<command> <redis-reset <player> | gamerules>")
@CommandParameters(name = "pdebug", description = "Plex's debug command", usage = "/<command> <aliases <command> | redis-reset <player> | gamerules>")
@CommandPermissions(level = Rank.EXECUTIVE, permission = "plex.debug")
@System(debug = true)
public class DebugCMD extends PlexCommand
@ -59,6 +61,16 @@ public class DebugCMD extends PlexCommand
}
return mmString("<aqua>Re-applied game all the game rules!");
}
if (args[0].equalsIgnoreCase("aliases"))
{
String commandName = args[1];
Command command = plugin.getServer().getCommandMap().getCommand(commandName);
if (command == null)
{
return mmString("<red>That command could not be found!");
}
return mmString("<aqua>Aliases for " + commandName + " are: " + Arrays.toString(command.getAliases().toArray(new String[0])));
}
return null;
}

View File

@ -1,6 +1,5 @@
package dev.plex.command.impl;
import com.google.common.collect.ImmutableList;
import dev.plex.command.PlexCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
@ -8,10 +7,12 @@ import dev.plex.command.source.RequiredCommandSource;
import dev.plex.rank.enums.Rank;
import dev.plex.util.PlexUtils;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import net.kyori.adventure.text.Component;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Entity;
@ -20,11 +21,6 @@ import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
@CommandPermissions(level = Rank.ADMIN, permission = "plex.entitywipe", source = RequiredCommandSource.ANY)
@CommandParameters(name = "entitywipe", description = "Remove various server entities that may cause lag, such as dropped items, minecarts, and boats.", usage = "/<command> [name]", aliases = "ew,rd")
public class EntityWipeCMD extends PlexCommand
@ -57,7 +53,7 @@ public class EntityWipeCMD extends PlexCommand
{
if (entity.getType() != EntityType.PLAYER)
{
String type = entity.getName();
String type = entity.getType().name();
if (useBlacklist ? entityBlacklist.stream().noneMatch(entityName -> entityName.equalsIgnoreCase(type)) : entityWhitelist.stream().anyMatch(entityName -> entityName.equalsIgnoreCase(type)))
{
@ -102,7 +98,7 @@ public class EntityWipeCMD extends PlexCommand
{
if (entity.getType() != EntityType.PLAYER)
{
entities.add(entity.getName());
entities.add(entity.getType().name());
}
}
}

View File

@ -17,7 +17,6 @@ import org.jetbrains.annotations.Nullable;
@CommandParameters(name = "flatlands", description = "Teleport to the flatlands")
public class FlatlandsCMD extends PlexCommand
{
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{

View File

@ -9,15 +9,14 @@ import dev.plex.punishment.Punishment;
import dev.plex.punishment.PunishmentType;
import dev.plex.rank.enums.Rank;
import dev.plex.util.PlexUtils;
import java.time.LocalDateTime;
import java.util.List;
import net.kyori.adventure.text.Component;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.time.LocalDateTime;
import java.util.List;
@CommandParameters(name = "freeze", description = "Freeze a player on the server", usage = "/<command> <player>", aliases = "fr")
@CommandPermissions(level = Rank.ADMIN, permission = "plex.freeze")
public class FreezeCMD extends PlexCommand

View File

@ -37,6 +37,10 @@ public class ListCMD extends PlexCommand
.append(Component.space())
.append(Component.text(Bukkit.getMaxPlayers() == 1 ? "player." : "players.").color(NamedTextColor.GRAY));
send(sender, header);
if (players.size() == 0)
{
return null;
}
for (int i = 0; i < players.size(); i++)
{
Player player = players.get(i);

View File

@ -17,7 +17,6 @@ import org.jetbrains.annotations.Nullable;
@CommandParameters(name = "masterbuilderworld", aliases = "mbw", description = "Teleport to the Master Builder world")
public class MasterbuilderworldCMD extends PlexCommand
{
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{

View File

@ -6,16 +6,17 @@ import dev.plex.command.annotation.CommandPermissions;
import dev.plex.command.source.RequiredCommandSource;
import dev.plex.rank.enums.Rank;
import dev.plex.util.PlexUtils;
import java.util.HashMap;
import net.kyori.adventure.text.Component;
import org.bukkit.Bukkit;
import org.bukkit.World;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.*;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Mob;
import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.HashMap;
@CommandPermissions(level = Rank.ADMIN, permission = "plex.mobpurge", source = RequiredCommandSource.ANY)
@CommandParameters(name = "mobpurge", description = "Purge all mobs.", usage = "/<command>", aliases = "mp")
public class MobPurgeCMD extends PlexCommand

View File

@ -11,7 +11,6 @@ import dev.plex.rank.enums.Rank;
import dev.plex.util.PlexUtils;
import java.time.LocalDateTime;
import java.util.List;
import java.util.UUID;
import net.kyori.adventure.text.Component;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;

View File

@ -10,7 +10,6 @@ import dev.plex.util.AshconInfo;
import dev.plex.util.MojangUtils;
import dev.plex.util.PlexLog;
import dev.plex.util.PlexUtils;
import java.time.format.DateTimeFormatter;
import java.util.Arrays;
import java.util.List;
import net.kyori.adventure.text.Component;
@ -24,8 +23,6 @@ import org.jetbrains.annotations.Nullable;
@CommandPermissions(level = Rank.OP, permission = "plex.namehistory")
public class NameHistoryCMD extends PlexCommand
{
private static final DateTimeFormatter DATE_FORMAT = DateTimeFormatter.ofPattern("MM/dd/yyyy 'at' hh:mm:ss a");
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{
@ -50,7 +47,7 @@ public class NameHistoryCMD extends PlexCommand
historyList.add(
messageComponent("nameHistoryBody",
history.getUsername(),
DATE_FORMAT.format(history.getLocalDateTime())));
PlexUtils.useTimezone(history.getLocalDateTime())));
}
else
{

View File

@ -9,9 +9,13 @@ import dev.plex.punishment.extra.Note;
import dev.plex.rank.enums.Rank;
import dev.plex.storage.StorageType;
import dev.plex.util.PlexUtils;
import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.atomic.AtomicReference;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.format.NamedTextColor;
import net.kyori.adventure.text.format.TextDecoration;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import org.bukkit.command.CommandSender;
@ -19,19 +23,10 @@ import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.atomic.AtomicReference;
@CommandParameters(name = "notes", description = "Manage notes for a player", usage = "/<command> <player> <list | add <note> | remove <id> | clear>")
@CommandPermissions(level = Rank.ADMIN, permission = "plex.notes")
public class NotesCMD extends PlexCommand
{
private static final DateTimeFormatter DATE_FORMAT = DateTimeFormatter.ofPattern("MM/dd/yyyy 'at' hh:mm:ss a");
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{
@ -94,6 +89,10 @@ public class NotesCMD extends PlexCommand
}
case "remove":
{
if (args.length < 3)
{
return usage();
}
int id;
try
{
@ -107,18 +106,20 @@ public class NotesCMD extends PlexCommand
{
plugin.getSqlNotes().getNotes(plexPlayer.getUuid()).whenComplete((notes, ex) ->
{
boolean deleted = false;
for (Note note : notes)
{
if (note.getId() == id)
{
plugin.getSqlNotes().deleteNote(id, plexPlayer.getUuid()).whenComplete((notes1, ex1) ->
send(sender, Component.text("Removed note with ID: " + id).color(NamedTextColor.GREEN)));
deleted = true;
}
else
}
if (!deleted)
{
send(sender, mmString("<red>A note with this ID could not be found"));
}
}
plexPlayer.getNotes().removeIf(note -> note.getId() == id);
});
}
@ -130,6 +131,7 @@ public class NotesCMD extends PlexCommand
}
return mmString("<red>A note with this ID could not be found");
}
return null;
}
case "clear":
{
@ -166,8 +168,8 @@ public class NotesCMD extends PlexCommand
AtomicReference<Component> noteList = new AtomicReference<>(Component.text("Player notes for: " + plexPlayer.getName()).color(NamedTextColor.GREEN));
for (Note note : notes)
{
Component noteLine = Component.text(note.getId() + " - Written by: " + DataUtils.getPlayer(note.getWrittenBy()).getName() + " on " + DATE_FORMAT.format(note.getTimestamp())).color(NamedTextColor.YELLOW).decoration(TextDecoration.ITALIC, false);
noteLine = noteLine.append(Component.text(note.getNote())).color(NamedTextColor.GOLD).decoration(TextDecoration.ITALIC, true);
Component noteLine = mmString("<gold><!italic>" + note.getId() + " - Written by: " + DataUtils.getPlayer(note.getWrittenBy()).getName() + " on " + PlexUtils.useTimezone(note.getTimestamp()));
noteLine = noteLine.append(mmString("<newline><yellow># " + note.getNote()));
noteList.set(noteList.get().append(Component.newline()));
noteList.set(noteList.get().append(noteLine));
}

View File

@ -9,16 +9,14 @@ import dev.plex.command.source.RequiredCommandSource;
import dev.plex.module.PlexModule;
import dev.plex.module.PlexModuleFile;
import dev.plex.rank.enums.Rank;
import dev.plex.util.PlexLog;
import dev.plex.util.PlexUtils;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
import dev.plex.util.PlexLog;
import dev.plex.util.PlexUtils;
import net.kyori.adventure.text.Component;
import org.apache.commons.lang.StringUtils;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull;
@ -52,12 +50,15 @@ public class PlexCMD extends PlexCommand
plugin.indefBans.load(false);
plugin.getPunishmentManager().mergeIndefiniteBans();
send(sender, "Reloaded indefinite bans");
plugin.blockedCommands.load();
plugin.getCommandBlockerManager().syncCommands();
plugin.commands.load();
send(sender, "Reloaded blocked commands file");
plugin.getRankManager().importDefaultRanks();
send(sender, "Imported ranks");
plugin.setSystem(plugin.config.getString("system"));
if (!plugin.setupPermissions() && plugin.getSystem().equalsIgnoreCase("permissions") && !plugin.getServer().getPluginManager().isPluginEnabled("Vault"))
{
throw new RuntimeException("Vault is required to run on the server if you use permissions!");
}
plugin.getServiceManager().endServices();
plugin.getServiceManager().startServices();
PlexLog.debug("Restarted services");

View File

@ -33,14 +33,14 @@ public class RankCMD extends PlexCommand
if (!(playerSender == null))
{
Rank rank = getPlexPlayer(playerSender).getRankFromString();
return messageComponent("yourRank", rank.getReadable());
return messageComponent("yourRank", rank.isAtLeast(Rank.ADMIN) && !getPlexPlayer(playerSender).isAdminActive() ? (playerSender.isOp() ? Rank.OP.getReadable() : Rank.NONOP.getReadable()) : rank.getReadable());
}
}
else
{
Player player = getNonNullPlayer(args[0]);
Rank rank = getPlexPlayer(player).getRankFromString();
return messageComponent("otherRank", player.getName(), rank.getReadable());
return messageComponent("otherRank", player.getName(), rank.isAtLeast(Rank.ADMIN) && !getPlexPlayer(player).isAdminActive() ? (player.isOp() ? Rank.OP.getReadable() : Rank.NONOP.getReadable()) : rank.getReadable());
}
return null;
}

View File

@ -14,7 +14,7 @@ import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@CommandPermissions(level = Rank.SENIOR_ADMIN, permission = "plex.rawsay", source = RequiredCommandSource.ANY)
@CommandParameters(name = "rawsay", usage = "/<command> <message>", description = "Displays a message to everyone")
@CommandParameters(name = "rawsay", usage = "/<command> <message>", description = "Displays a raw message to everyone")
public class RawSayCMD extends PlexCommand
{
@Override

View File

@ -0,0 +1,31 @@
package dev.plex.command.impl;
import dev.plex.command.PlexCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
import dev.plex.command.source.RequiredCommandSource;
import dev.plex.rank.enums.Rank;
import dev.plex.util.PlexUtils;
import net.kyori.adventure.text.Component;
import org.apache.commons.lang.StringUtils;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@CommandPermissions(level = Rank.ADMIN, permission = "plex.say", source = RequiredCommandSource.ANY)
@CommandParameters(name = "say", usage = "/<command> <message>", description = "Displays a message to everyone")
public class SayCMD extends PlexCommand
{
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{
if (args.length == 0)
{
return usage();
}
PlexUtils.broadcast(PlexUtils.messageComponent("sayMessage", sender.getName(), PlexUtils.mmStripColor(StringUtils.join(args, " "))));
return null;
}
}

View File

@ -7,9 +7,10 @@ import dev.plex.command.annotation.CommandPermissions;
import dev.plex.command.source.RequiredCommandSource;
import dev.plex.player.PlexPlayer;
import dev.plex.rank.enums.Rank;
import dev.plex.util.PlexUtils;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.minimessage.MiniMessage;
import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
import net.kyori.adventure.text.minimessage.tag.standard.StandardTags;
import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
import org.apache.commons.lang.StringUtils;
import org.bukkit.command.CommandSender;
@ -47,15 +48,15 @@ public class TagCMD extends PlexCommand
return usage("/tag set <prefix>");
}
String prefix = StringUtils.join(args, " ", 1, args.length);
Component convertedComponent = removeEvents(noColorComponentFromString(prefix));
convertedComponent = removeEvents(MiniMessage.miniMessage().deserialize(LegacyComponentSerializer.legacySection().serialize(convertedComponent)));
Component convertedComponent = removeEvents(PlexUtils.mmCustomDeserialize(prefix = prefix.replace("<newline>", "").replace("<br>", ""), StandardTags.color(), StandardTags.rainbow(), StandardTags.decorations(), StandardTags.gradient(), StandardTags.transition())); //noColorComponentFromString(prefix)
if (PlainTextComponentSerializer.plainText().serialize(convertedComponent).length() > plugin.config.getInt("chat.max-tag-length", 16))
{
return messageComponent("maximumPrefixLength", plugin.config.getInt("chat.max-tag-length", 16));
}
player.setPrefix(MiniMessage.miniMessage().serialize(convertedComponent));
player.setPrefix(prefix);
DataUtils.update(player);
return messageComponent("prefixSetTo", MiniMessage.miniMessage().serialize(convertedComponent));
}
@ -85,7 +86,7 @@ public class TagCMD extends PlexCommand
PlexPlayer plexTarget = DataUtils.getPlayer(target.getUniqueId());
plexTarget.setPrefix("");
DataUtils.update(plexTarget);
messageComponent("otherPrefixCleared");
return messageComponent("otherPrefixCleared", target.getName());
}
return usage();
}

View File

@ -5,24 +5,12 @@ import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
import dev.plex.command.source.RequiredCommandSource;
import dev.plex.rank.enums.Rank;
import dev.plex.services.ServiceManager;
import dev.plex.services.impl.AutoWipeService;
import dev.plex.util.PlexUtils;
import net.kyori.adventure.text.Component;
import org.bukkit.Bukkit;
import org.bukkit.World;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Entity;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
@CommandPermissions(level = Rank.ADMIN, permission = "plex.toggledrops", source = RequiredCommandSource.ANY)
@CommandParameters(name = "toggledrops", description = "Toggle immediately removing drops.", usage = "/<command>", aliases = "td")
public class ToggleDropsCMD extends PlexCommand

View File

@ -14,7 +14,6 @@ import dev.plex.util.PlexUtils;
import java.util.List;
import java.util.UUID;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.minimessage.MiniMessage;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull;
@ -47,7 +46,7 @@ public class UnbanCMD extends PlexCommand
PlexPlayer plexPlayer = getOfflinePlexPlayer(targetUUID);
if (!aBoolean)
{
send(sender, MiniMessage.miniMessage().deserialize(new PlayerNotBannedException().getMessage()));
send(sender, PlexUtils.mmDeserialize(new PlayerNotBannedException().getMessage()));
return;
}
plugin.getPunishmentManager().unban(targetUUID);

View File

@ -8,7 +8,7 @@ import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
/**
* Event that is ran when a player is added to the admin list
* Event that is run when a player is added to the admin list
*/
@EqualsAndHashCode(callSuper = false)
@Data

View File

@ -8,7 +8,7 @@ import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
/**
* Event that is ran when a player is removed from the admin list
* Event that is run when a player is removed from the admin list
*/
@EqualsAndHashCode(callSuper = false)
@Data

View File

@ -9,7 +9,7 @@ import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
/**
* Event that is ran when an admin's rank is set
* Event that is run when an admins rank is set
*/
@EqualsAndHashCode(callSuper = false)
@Data

View File

@ -1,7 +1,6 @@
package dev.plex.event;
import dev.plex.player.PlexPlayer;
import java.util.UUID;
import lombok.Getter;
import lombok.Setter;
import org.bukkit.Bukkit;

View File

@ -39,7 +39,8 @@ public class CommandHandler extends PlexBase
commands.add(clazz.getConstructor().newInstance());
}
}
catch (InvocationTargetException | InstantiationException | IllegalAccessException | NoSuchMethodException ex)
catch (InvocationTargetException | InstantiationException | IllegalAccessException |
NoSuchMethodException ex)
{
PlexLog.error("Failed to register " + clazz.getSimpleName() + " as a command!");
}

View File

@ -34,7 +34,8 @@ public class ListenerHandler extends PlexBase
listeners.add(clazz.getConstructor().newInstance());
}
}
catch (InvocationTargetException | InstantiationException | IllegalAccessException | NoSuchMethodException ex)
catch (InvocationTargetException | InstantiationException | IllegalAccessException |
NoSuchMethodException ex)
{
PlexLog.error("Failed to register " + clazz.getSimpleName() + " as a listener!");
}

View File

@ -18,16 +18,17 @@ public class AdminListener extends PlexListener
{
String userSender = event.getSender().getName();
PlexPlayer target = event.getPlexPlayer();
if (!target.getRank().isEmpty())
if (target.getRankFromString().isAtLeast(Rank.ADMIN))
{
PlexUtils.broadcast(messageComponent("adminReadded", userSender, target.getName(), target.getRankFromString().getReadable()));
} else {
}
else
{
target.setRank(Rank.ADMIN.name());
PlexUtils.broadcast(messageComponent("newAdminAdded", userSender, target.getName()));
}
target.setAdminActive(true);
DataUtils.update(target);
}
@EventHandler
@ -35,7 +36,6 @@ public class AdminListener extends PlexListener
{
String userSender = event.getSender().getName();
PlexPlayer target = event.getPlexPlayer();
// target.setRank("");
target.setAdminActive(false);
DataUtils.update(target);
PlexUtils.broadcast(messageComponent("adminRemoved", userSender, target.getName()));

View File

@ -1,11 +1,10 @@
package dev.plex.listener.impl;
import dev.plex.listener.PlexListener;
import dev.plex.util.PlexUtils;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import dev.plex.util.PlexUtils;
import net.kyori.adventure.text.Component;
import org.bukkit.Material;
import org.bukkit.block.Block;
@ -28,7 +27,7 @@ public class BlockListener extends PlexListener
@EventHandler(priority = EventPriority.LOW)
public void onBlockPlace(BlockPlaceEvent event)
{
List<String> blockedBlocksConfig = plugin.config.getStringList("blockedBlocks");
List<String> blockedBlocksConfig = plugin.config.getStringList("blocked_blocks");
if (blockedBlocksConfig != cachedBlockedBlocksConfig)
{
blockedBlocks.clear();

View File

@ -1,6 +1,6 @@
package dev.plex.listener.impl;
import dev.plex.cache.player.PlayerCache;
import dev.plex.cache.PlayerCache;
import dev.plex.listener.PlexListener;
import dev.plex.listener.annotation.Toggleable;
import dev.plex.player.PlexPlayer;
@ -9,7 +9,7 @@ import io.papermc.paper.event.player.AsyncChatEvent;
import net.kyori.adventure.audience.Audience;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.format.NamedTextColor;
import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
import net.kyori.adventure.text.minimessage.MiniMessage;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.jetbrains.annotations.NotNull;
@ -51,14 +51,14 @@ public class ChatListener extends PlexListener
return Component.empty()
.append(prefix)
.append(Component.space())
.append(LegacyComponentSerializer.legacyAmpersand().deserialize("&" + plugin.config.getString("chat.name-color") + LegacyComponentSerializer.legacyAmpersand().serialize(sourceDisplayName)))
.append(MiniMessage.miniMessage().deserialize(plugin.config.getString("chat.name-color", "<white>"))).append(sourceDisplayName)
.append(Component.space())
.append(Component.text("»").color(NamedTextColor.GRAY))
.append(Component.space())
.append(message);
}
return Component.empty()
.append(LegacyComponentSerializer.legacyAmpersand().deserialize("&" + plugin.config.getString("chat.name-color") + LegacyComponentSerializer.legacyAmpersand().serialize(sourceDisplayName)))
.append(MiniMessage.miniMessage().deserialize(plugin.config.getString("chat.name-color", "<white>"))).append(sourceDisplayName)
.append(Component.space())
.append(Component.text("»").color(NamedTextColor.GRAY))
.append(Component.space())

View File

@ -1,14 +1,18 @@
package dev.plex.listener.impl;
import dev.plex.cache.DataUtils;
import dev.plex.cache.player.PlayerCache;
import dev.plex.command.blocker.BaseCommand;
import dev.plex.command.blocker.MatchCommand;
import dev.plex.command.blocker.RegexCommand;
import dev.plex.cache.PlayerCache;
import dev.plex.command.blocking.BlockedCommand;
import dev.plex.listener.PlexListener;
import dev.plex.player.PlexPlayer;
import dev.plex.util.PlexUtils;
import net.kyori.adventure.text.minimessage.MiniMessage;
import dev.plex.rank.enums.Rank;
import dev.plex.services.impl.CommandBlockerService;
import dev.plex.util.PlexLog;
import java.util.Locale;
import java.util.concurrent.atomic.AtomicReference;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.commons.lang.StringUtils;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.entity.Player;
@ -30,44 +34,100 @@ public class CommandListener extends PlexListener
pl.sendMessage(ChatColor.GRAY + player.getName() + ": " + command);
}
});
if (!plugin.getCommandBlockerManager().loadedYet)
{
event.setCancelled(true);
return;
}
@EventHandler(priority = EventPriority.HIGHEST)
public void onCommandBlocking(PlayerCommandPreprocessEvent event)
{
Player player = event.getPlayer();
String message = event.getMessage().substring(1).stripLeading(); // stripLeading() is VITAL for workaround blocking (/ minecraft:summon)
for (BaseCommand blockedCommand : plugin.getCommandBlockerManager().getBlockedCommands())
{
PlexPlayer plexPlayer = DataUtils.getPlayer(player.getUniqueId());
if (blockedCommand.getRank() != null && plexPlayer.getRankFromString().isAtLeast(blockedCommand.getRank()))
String commandName = StringUtils.normalizeSpace(event.getMessage()).split(" ")[0].replaceFirst("/", "");
String arguments = StringUtils.normalizeSpace(StringUtils.normalizeSpace(event.getMessage()).replace(event.getMessage().split(" ")[0], ""));
PlexLog.debug("Checking Command: {0} with args {1}", commandName, arguments);
AtomicReference<BlockedCommand> cmdRef = new AtomicReference<>();
PlexLog.debug("Blocked Commands List: " + CommandBlockerService.getBLOCKED_COMMANDS().size());
CommandBlockerService.getBLOCKED_COMMANDS().stream().filter(blockedCommand -> blockedCommand.getCommand() != null).forEach(blockedCommand ->
{
continue;
boolean matches = true;
String[] args = blockedCommand.getCommand().split(" ");
String[] cmdArgs = event.getMessage().replaceFirst("/", "").split(" ");
for (int i = 0; i < args.length; i++)
{
if (i + 1 > cmdArgs.length)
{
matches = false;
break;
}
boolean isBlocked = false;
if (blockedCommand instanceof RegexCommand regexCommand)
if (!args[i].equalsIgnoreCase(cmdArgs[i]))
{
if (regexCommand.getRegex().matcher(message).lookingAt())
{
isBlocked = true;
matches = false;
break;
}
}
else if (blockedCommand instanceof MatchCommand matchCommand)
if (matches)
{
if (message.toLowerCase().startsWith(matchCommand.getMatch().toLowerCase()))
{
isBlocked = true;
PlexLog.debug("Used blocked command exactly matched");
cmdRef.set(blockedCommand);
return;
}
}
if (isBlocked)
if (blockedCommand.getCommandAliases().stream().anyMatch(s -> s.equalsIgnoreCase(commandName)))
{
event.setCancelled(true);
//PlexLog.debug("Command blocked.");
player.sendMessage(MiniMessage.miniMessage().deserialize(PlexUtils.messageString("blockedCommandColor") + blockedCommand.getMessage()));
PlexLog.debug("Found a command name in a blocked command alias, checking arguments now.");
String[] commandArgs = blockedCommand.getCommand().split(" ");
if (arguments.toLowerCase(Locale.ROOT).startsWith(StringUtils.join(commandArgs, " ", 1, commandArgs.length).toLowerCase(Locale.ROOT)))
{
PlexLog.debug("Player attempted to use a blocked command with an alias.");
cmdRef.set(blockedCommand);
return;
}
}
});
if (cmdRef.get() == null)
{
CommandBlockerService.getBLOCKED_COMMANDS().forEach(blockedCommand ->
{
if (blockedCommand.getRegex() != null)
{
Pattern pattern = Pattern.compile(blockedCommand.getRegex(), Pattern.CASE_INSENSITIVE);
Matcher matcher = pattern.matcher(event.getMessage().replaceFirst("/", ""));
if (matcher.find())
{
PlexLog.debug("Player attempted to use a blocked regex");
cmdRef.set(blockedCommand);
}
}
});
}
if (cmdRef.get() != null)
{
BlockedCommand cmd = cmdRef.get();
switch (cmd.getRequiredLevel().toLowerCase(Locale.ROOT))
{
case "e" ->
{
event.setCancelled(true);
event.getPlayer().sendMessage(cmd.getMessage());
}
case "a" ->
{
if (plexPlayer.isAdminActive() && plexPlayer.getRankFromString().isAtLeast(Rank.ADMIN))
{
return;
}
event.setCancelled(true);
event.getPlayer().sendMessage(cmd.getMessage());
}
case "s" ->
{
if (plexPlayer.isAdminActive() && plexPlayer.getRankFromString().isAtLeast(Rank.SENIOR_ADMIN))
{
return;
}
event.setCancelled(true);
event.getPlayer().sendMessage(cmd.getMessage());
}
}
}
}
}

View File

@ -9,6 +9,9 @@ public class DropListener extends PlexListener
@EventHandler
public void onPlayerDropItem(PlayerDropItemEvent event)
{
if (!plugin.config.getBoolean("allowdrops")) event.setCancelled(true);
if (!plugin.config.getBoolean("allowdrops"))
{
event.setCancelled(true);
}
}
}

View File

@ -1,13 +1,17 @@
package dev.plex.listener.impl;
import dev.plex.cache.DataUtils;
import dev.plex.cache.player.PlayerCache;
import dev.plex.cache.PlayerCache;
import dev.plex.listener.PlexListener;
import dev.plex.player.PlexPlayer;
import dev.plex.storage.StorageType;
import dev.plex.util.PlexLog;
import dev.plex.util.PlexUtils;
import net.kyori.adventure.text.minimessage.MiniMessage;
import java.util.Arrays;
import java.util.List;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.event.ClickEvent;
import net.kyori.adventure.text.format.NamedTextColor;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
@ -17,10 +21,7 @@ import org.bukkit.event.inventory.InventoryCloseEvent;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import java.util.Arrays;
import java.util.List;
public class PlayerListener extends PlexListener
public class PlayerListener<T> extends PlexListener
{
// setting up a player's data
@EventHandler(priority = EventPriority.HIGHEST)
@ -73,20 +74,28 @@ public class PlayerListener extends PlexListener
player.openInventory(player.getInventory());
}
assert plexPlayer != null;
String loginMessage = plugin.getRankManager().getLoginMessage(plexPlayer);
if (!loginMessage.isEmpty())
{
PlexUtils.broadcast(MiniMessage.miniMessage().deserialize("<aqua>" + player.getName() + " is " + loginMessage));
PlexUtils.broadcast(PlexUtils.mmDeserialize("<aqua>" + player.getName() + " is " + loginMessage));
}
PlexUtils.setupPermissions(player);
if (plugin.getStorageType() != StorageType.MONGODB)
{
plexPlayer.loadNotes().whenComplete((notes, throwable) ->
{
//TODO: Send note messages to admins
});
plexPlayer.loadNotes();
}
plugin.getSqlNotes().getNotes(plexPlayer.getUuid()).whenComplete((notes, ex) ->
{
String plural = notes.size() == 1 ? "note." : "notes.";
if (!notes.isEmpty())
{
PlexUtils.broadcastToAdmins(Component.text(plexPlayer.getName() + " has " + notes.size() + " " + plural).color(NamedTextColor.GOLD));
PlexUtils.broadcastToAdmins(Component.text("Click to view their " + plural).clickEvent(ClickEvent.runCommand("/notes " + plexPlayer.getName() + " list")).color(NamedTextColor.GOLD));
}
});
}
// saving the player's data

View File

@ -2,6 +2,9 @@ package dev.plex.listener.impl;
import dev.plex.listener.PlexListener;
import dev.plex.util.PlexUtils;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.block.Block;
@ -20,10 +23,6 @@ import org.bukkit.event.player.PlayerInteractEntityEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.inventory.ItemStack;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
public class SpawnListener extends PlexListener
{
private static final List<Material> SPAWN_EGGS = Arrays.stream(Material.values()).filter((mat) -> mat.name().endsWith("_SPAWN_EGG")).toList();
@ -39,7 +38,7 @@ public class SpawnListener extends PlexListener
return;
}
if (plugin.config.getStringList("blockedEntities").stream().anyMatch(type -> type.equalsIgnoreCase(event.getEntityType().name())))
if (plugin.config.getStringList("blocked_entities").stream().anyMatch(type -> type.equalsIgnoreCase(event.getEntityType().name())))
{
event.setCancelled(true);
Location location = event.getLocation();
@ -109,7 +108,8 @@ public class SpawnListener extends PlexListener
}
}
private static EntityType spawnEggToEntityType(Material mat){
private static EntityType spawnEggToEntityType(Material mat)
{
EntityType eggType;
try
{

View File

@ -2,7 +2,7 @@ package dev.plex.listener.impl;
import dev.plex.Plex;
import dev.plex.cache.DataUtils;
import dev.plex.cache.player.PlayerCache;
import dev.plex.cache.PlayerCache;
import dev.plex.listener.PlexListener;
import dev.plex.player.PlexPlayer;
import dev.plex.rank.enums.Rank;
@ -21,7 +21,6 @@ import org.bukkit.event.EventHandler;
import org.bukkit.event.block.BlockBreakEvent;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.event.entity.EntitySpawnEvent;
import org.bukkit.event.player.PlayerChangedWorldEvent;
import org.bukkit.event.player.PlayerTeleportEvent;
import org.jetbrains.annotations.NotNull;
@ -157,16 +156,20 @@ public class WorldListener extends PlexListener
Title title = Title.valueOf(titleString.toUpperCase(Locale.ROOT));
switch (title)
{
case DEV -> {
case DEV ->
{
hasAccess = PlexUtils.DEVELOPERS.contains(player.getUuid().toString());
}
case MASTER_BUILDER -> {
case MASTER_BUILDER ->
{
hasAccess = Plex.get().config.contains("titles.masterbuilders") && Plex.get().config.getStringList("titles.masterbuilders").contains(player.getName());
}
case OWNER -> {
case OWNER ->
{
hasAccess = Plex.get().config.contains("titles.owners") && Plex.get().config.getStringList("titles.owners").contains(player.getName());
}
default -> {
default ->
{
return false;
}
}

View File

@ -2,9 +2,10 @@ package dev.plex.menu;
import com.google.common.collect.Lists;
import dev.plex.cache.DataUtils;
import dev.plex.cache.player.PlayerCache;
import dev.plex.cache.PlayerCache;
import dev.plex.player.PlexPlayer;
import dev.plex.punishment.Punishment;
import dev.plex.util.PlexUtils;
import dev.plex.util.menu.AbstractMenu;
import java.util.Collections;
import java.util.List;
@ -34,7 +35,7 @@ public class PunishedPlayerMenu extends AbstractMenu
this.punishedPlayer = player;
for (int i = 0; i <= punishedPlayer.getPunishments().size() / 53; i++)
{
Inventory inventory = Bukkit.createInventory(null, 54, "Punishments Page " + (i + 1));
Inventory inventory = Bukkit.createInventory(null, 54, PlexUtils.mmDeserialize("Punishments Page " + (i + 1)));
ItemStack nextPage = new ItemStack(Material.FEATHER);
ItemMeta meta = nextPage.getItemMeta();
meta.displayName(Component.text("Next Page").color(NamedTextColor.LIGHT_PURPLE));

View File

@ -3,6 +3,7 @@ package dev.plex.menu;
import com.google.common.collect.Lists;
import dev.plex.cache.DataUtils;
import dev.plex.player.PlexPlayer;
import dev.plex.util.PlexUtils;
import dev.plex.util.menu.AbstractMenu;
import java.util.List;
import org.bukkit.Bukkit;
@ -27,15 +28,15 @@ public class PunishmentMenu extends AbstractMenu
super("§c§lPunishments");
for (int i = 0; i <= Bukkit.getOnlinePlayers().size() / 53; i++)
{
Inventory inventory = Bukkit.createInventory(null, 54, "Punishments Page " + (i + 1));
Inventory inventory = Bukkit.createInventory(null, 54, PlexUtils.mmDeserialize("Punishments Page " + (i + 1)));
ItemStack nextPage = new ItemStack(Material.FEATHER);
ItemMeta meta = nextPage.getItemMeta();
meta.setDisplayName(ChatColor.LIGHT_PURPLE + "Next Page");
meta.displayName(PlexUtils.mmDeserialize("<light_purple>Next Page"));
nextPage.setItemMeta(meta);
ItemStack previousPage = new ItemStack(Material.FEATHER);
ItemMeta meta2 = previousPage.getItemMeta();
meta2.setDisplayName(ChatColor.LIGHT_PURPLE + "Previous Page");
meta2.displayName(PlexUtils.mmDeserialize("<light_purple>Previous Page"));
previousPage.setItemMeta(meta2);
inventory.setItem(50, nextPage);
@ -72,7 +73,7 @@ public class PunishmentMenu extends AbstractMenu
ItemStack item = new ItemStack(Material.PLAYER_HEAD);
SkullMeta meta = (SkullMeta)item.getItemMeta();
meta.setOwningPlayer(players);
meta.setDisplayName(ChatColor.YELLOW + players.getName());
meta.displayName(PlexUtils.mmDeserialize("<!italic><yellow>" + players.getName()));
item.setItemMeta(meta);
inv.setItem(currentItemIndex, item);
@ -98,11 +99,19 @@ public class PunishmentMenu extends AbstractMenu
{
return;
}
if (!event.getCurrentItem().hasItemMeta())
{
return;
}
if (!event.getCurrentItem().getItemMeta().hasDisplayName())
{
return;
}
ItemStack item = event.getCurrentItem();
event.setCancelled(true);
if (item.getType() == Material.FEATHER)
{
if (item.getItemMeta().getDisplayName().equalsIgnoreCase(ChatColor.LIGHT_PURPLE + "Next Page"))
if (item.getItemMeta().displayName().equals(PlexUtils.mmDeserialize("<light_purple>Next Page")))
{
if (getCurrentInventoryIndex(inv) + 1 > inventories.size() - 1)
{
@ -114,7 +123,7 @@ public class PunishmentMenu extends AbstractMenu
}
openInv((Player)event.getWhoClicked(), getCurrentInventoryIndex(inv) + 1);
}
else if (item.getItemMeta().getDisplayName().equalsIgnoreCase(ChatColor.LIGHT_PURPLE + "Previous Page"))
else if (item.getItemMeta().displayName().equals(PlexUtils.mmDeserialize("<light_purple>Previous Page")))
{
if (getCurrentInventoryIndex(inv) - 1 < 0)
{

View File

@ -82,7 +82,8 @@ public class ModuleManager
plexModule.setLogger(LogManager.getLogger(plexModuleFile.getName()));
modules.add(plexModule);
}
catch (MalformedURLException | ClassNotFoundException | InvocationTargetException | InstantiationException | IllegalAccessException | NoSuchMethodException e)
catch (MalformedURLException | ClassNotFoundException | InvocationTargetException |
InstantiationException | IllegalAccessException | NoSuchMethodException e)
{
e.printStackTrace();
}

View File

@ -0,0 +1,14 @@
package dev.plex.permission;
import dev.morphia.annotations.Entity;
import java.util.UUID;
import lombok.Data;
@Data
@Entity
public class Permission
{
private final UUID uuid;
private final String permission;
private boolean allowed = true;
}

View File

@ -7,18 +7,16 @@ import dev.morphia.annotations.Id;
import dev.morphia.annotations.IndexOptions;
import dev.morphia.annotations.Indexed;
import dev.plex.Plex;
import dev.plex.permission.Permission;
import dev.plex.punishment.Punishment;
import dev.plex.punishment.extra.Note;
import dev.plex.rank.enums.Rank;
import dev.plex.storage.StorageType;
import dev.plex.util.adapter.LocalDateTimeSerializer;
import java.time.LocalDateTime;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;
import dev.plex.util.adapter.LocalDateTimeSerializer;
import lombok.AccessLevel;
import lombok.Getter;
import lombok.Setter;
@ -26,6 +24,7 @@ import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
import org.bukkit.Bukkit;
import org.bukkit.OfflinePlayer;
import org.bukkit.entity.Player;
import org.bukkit.permissions.PermissionAttachment;
@Getter
@Setter
@ -64,6 +63,9 @@ public class PlexPlayer
private List<String> ips = Lists.newArrayList();
private List<Punishment> punishments = Lists.newArrayList();
private List<Note> notes = Lists.newArrayList();
private List<Permission> permissions = Lists.newArrayList();
private transient PermissionAttachment permissionAttachment;
public PlexPlayer()
{
@ -88,6 +90,10 @@ public class PlexPlayer
this.rank = "";
this.loadPunishments();
if (Plex.get().getStorageType() != StorageType.MONGODB)
{
this.permissions.addAll(Plex.get().getSqlPermissions().getPermissions(this.uuid));
}
}
public String displayName()
@ -119,7 +125,7 @@ public class PlexPlayer
{
if (Plex.get().getStorageType() != StorageType.MONGODB)
{
this.setPunishments(Plex.get().getSqlPunishment().getPunishments(this.getUuid()).stream().filter(punishment -> punishment.getPunished().equals(this.getUuid())).collect(Collectors.toList()));
this.setPunishments(Plex.get().getSqlPunishment().getPunishments(this.getUuid()));
}
}

View File

@ -8,7 +8,6 @@ import dev.plex.util.PlexUtils;
import dev.plex.util.adapter.LocalDateTimeDeserializer;
import dev.plex.util.adapter.LocalDateTimeSerializer;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.UUID;
import lombok.Getter;
import lombok.Setter;
@ -20,7 +19,6 @@ import net.kyori.adventure.text.Component;
public class Punishment
{
private static final String banUrl = Plex.get().config.getString("banning.ban_url");
private static final DateTimeFormatter DATE_FORMAT = DateTimeFormatter.ofPattern("MM/dd/yyyy 'at' hh:mm:ss a");
private final UUID punished;
private final UUID punisher;
private String ip;
@ -46,7 +44,8 @@ public class Punishment
public static Component generateBanMessage(Punishment punishment)
{
return PlexUtils.messageComponent("banMessage", banUrl, punishment.getReason(),
DATE_FORMAT.format(punishment.getEndDate()), punishment.getPunisher() == null ? "CONSOLE" : MojangUtils.getInfo(punishment.getPunisher().toString()).getUsername());
PlexUtils.useTimezone(punishment.getEndDate()),
punishment.getPunisher() == null ? "CONSOLE" : MojangUtils.getInfo(punishment.getPunisher().toString()).getUsername());
}
public static Component generateIndefBanMessage(String type)

View File

@ -159,10 +159,14 @@ public class PunishmentManager extends PlexBase
}
else
{
PlexLog.debug("Checking active bans mysql");
CompletableFuture<List<Punishment>> future = new CompletableFuture<>();
Plex.get().getSqlPunishment().getPunishments().whenComplete((punishments, throwable) ->
{
future.complete(punishments.stream().filter(Punishment::isActive).filter(punishment -> punishment.getType() == PunishmentType.BAN).toList());
PlexLog.debug("Received Punishments");
List<Punishment> punishmentList = punishments.stream().filter(Punishment::isActive).filter(punishment -> punishment.getType() == PunishmentType.BAN).toList();
PlexLog.debug("Completing with {0} punishments", punishmentList.size());
future.complete(punishmentList);
});
return future;
}

View File

@ -3,10 +3,9 @@ package dev.plex.punishment.extra;
import com.google.gson.GsonBuilder;
import dev.morphia.annotations.Entity;
import dev.plex.util.adapter.LocalDateTimeSerializer;
import lombok.Data;
import java.time.LocalDateTime;
import java.util.UUID;
import lombok.Data;
@Data
@Entity

View File

@ -14,7 +14,7 @@ import java.util.stream.Collectors;
import lombok.SneakyThrows;
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.tag.standard.StandardTags;
import org.json.JSONArray;
import org.json.JSONObject;
import org.json.JSONTokener;
@ -95,7 +95,7 @@ public class RankManager
{
if (!player.getPrefix().equals(""))
{
return MiniMessage.miniMessage().deserialize(player.getPrefix());
return PlexUtils.mmCustomDeserialize(player.getPrefix(), StandardTags.color(), StandardTags.rainbow(), StandardTags.decorations(), StandardTags.gradient(), StandardTags.transition());
}
if (Plex.get().config.contains("titles.owners") && Plex.get().config.getStringList("titles.owners").contains(player.getName()))
{

View File

@ -1,10 +1,10 @@
package dev.plex.rank.enums;
import dev.plex.util.PlexUtils;
import lombok.Getter;
import lombok.Setter;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.format.NamedTextColor;
import net.kyori.adventure.text.minimessage.MiniMessage;
import org.json.JSONObject;
@Getter
@ -47,7 +47,7 @@ public enum Rank
public Component getPrefix()
{
return MiniMessage.miniMessage().deserialize(this.prefix);
return PlexUtils.mmDeserialize(this.prefix);
}
public JSONObject toJSON()

View File

@ -1,10 +1,10 @@
package dev.plex.rank.enums;
import dev.plex.util.PlexUtils;
import lombok.Getter;
import lombok.Setter;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.format.NamedTextColor;
import net.kyori.adventure.text.minimessage.MiniMessage;
import org.json.JSONObject;
@Getter
@ -39,7 +39,7 @@ public enum Title
public Component getPrefix()
{
return MiniMessage.miniMessage().deserialize(this.prefix);
return PlexUtils.mmDeserialize(this.prefix);
}
public JSONObject toJSON()

View File

@ -2,12 +2,15 @@ package dev.plex.services;
import com.google.common.collect.Lists;
import dev.plex.Plex;
import dev.plex.services.impl.*;
import dev.plex.services.impl.AutoWipeService;
import dev.plex.services.impl.BanService;
import dev.plex.services.impl.CommandBlockerService;
import dev.plex.services.impl.GameRuleService;
import dev.plex.services.impl.UpdateCheckerService;
import java.util.List;
import org.bukkit.Bukkit;
import org.bukkit.scheduler.BukkitTask;
import java.util.List;
public class ServiceManager
{
private final List<AbstractService> services = Lists.newArrayList();

View File

@ -2,12 +2,10 @@ package dev.plex.services.impl;
import dev.plex.Plex;
import dev.plex.services.AbstractService;
import java.util.List;
import org.bukkit.Bukkit;
import org.bukkit.World;
import org.bukkit.entity.Entity;
import org.bukkit.entity.EntityType;
import java.util.List;
public class AutoWipeService extends AbstractService
{

View File

@ -1,20 +1,69 @@
package dev.plex.services.impl;
import com.google.common.collect.Lists;
import dev.plex.command.blocking.BlockedCommand;
import dev.plex.services.AbstractService;
import dev.plex.util.PlexLog;
import dev.plex.util.PlexUtils;
import java.util.List;
import java.util.Locale;
import lombok.Getter;
import org.bukkit.command.Command;
public class CommandBlockerService extends AbstractService
{
@Getter
private static final List<BlockedCommand> BLOCKED_COMMANDS = Lists.newArrayList();
public CommandBlockerService()
{
super(false, true);
super(false, false);
}
@Override
public void run()
{
plugin.getCommandBlockerManager().syncCommands();
PlexLog.log("Command Blocker commands loaded");
BLOCKED_COMMANDS.clear();
plugin.commands.getStringList("commands").forEach(s ->
{
BlockedCommand command = new BlockedCommand();
int lastDelim = s.lastIndexOf(':');
String cmdWithoutMsg = s.substring(0, lastDelim);
String[] args = cmdWithoutMsg.split(":", 3); // Delimiter code by ayunami
if (s.toLowerCase(Locale.ROOT).startsWith("r"))
{
command.setRequiredLevel(args[1]);
command.setRegex(args[2]);
command.setMessage(s.substring(lastDelim + 1).equalsIgnoreCase("_") ? PlexUtils.messageComponent("commandBlocked") : PlexUtils.mmDeserialize(s.substring(lastDelim + 1)));
/*PlexLog.debug("=Found regex blocked=");
PlexLog.debug(" Regex: " + command.getRegex());
PlexLog.debug(" Message: " + command.getMessage());
PlexLog.debug("====================");*/
}
else if (s.toLowerCase(Locale.ROOT).startsWith("m"))
{
command.setRequiredLevel(args[1]);
command.setCommand(args[2]);
command.setMessage(s.substring(lastDelim + 1).equalsIgnoreCase("_") ? PlexUtils.messageComponent("commandBlocked") : PlexUtils.mmDeserialize(s.substring(lastDelim + 1)));
Command cmd = plugin.getServer().getCommandMap().getCommand(command.getCommand().split(" ")[0]);
if (cmd == null)
{
PlexLog.error("Command '{0}' does not belong to any plugin!", command.getCommand().split(" ")[0]);
return;
}
command.setCommandAliases(cmd.getAliases());
command.getCommandAliases().add(command.getCommand().split(" ")[0]);
/*PlexLog.debug("=Found command blocked=");
PlexLog.debug(" Required Level: " + command.getRequiredLevel());
PlexLog.debug(" Command: " + command.getCommand());
PlexLog.debug(" Message: " + command.getMessage());
PlexLog.debug(" Aliases: " + Arrays.toString(command.getCommandAliases().toArray(new String[0])));
PlexLog.debug("====================");*/
}
BLOCKED_COMMANDS.add(command);
});
PlexLog.log("Command Blocker has loaded {0} entries!", BLOCKED_COMMANDS.size());
}
@Override

View File

@ -1,6 +1,5 @@
package dev.plex.storage;
import com.mongodb.*;
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import dev.morphia.Datastore;
@ -32,10 +31,14 @@ public class MongoConnection extends PlexBase
if (database != null && !database.isEmpty())
{
connectionString = "mongodb://" + username + ":" + password + "@" + host + ":" + port + "/?authSource=" + database;
} else {
}
else
{
connectionString = "mongodb://" + username + ":" + password + "@" + host + ":" + port + "/";
}
} else {
}
else
{
connectionString = "mongodb://" + host + ":" + port + "/";
}
connectionString += "?uuidRepresentation=STANDARD";

View File

@ -4,11 +4,10 @@ import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import dev.plex.Plex;
import dev.plex.PlexBase;
import lombok.Getter;
import java.io.File;
import java.sql.Connection;
import java.sql.SQLException;
import lombok.Getter;
@Getter
public class SQLConnection extends PlexBase
@ -45,7 +44,8 @@ public class SQLConnection extends PlexBase
{
dataSource.setJdbcUrl("jdbc:sqlite:" + new File(plugin.getDataFolder(), "database.db").getAbsolutePath());
plugin.setStorageType(StorageType.SQLITE);
} else if (plugin.config.getString("data.central.storage").equalsIgnoreCase("mariadb"))
}
else if (plugin.config.getString("data.central.storage").equalsIgnoreCase("mariadb"))
{
Class.forName("org.mariadb.jdbc.Driver");
dataSource.setJdbcUrl("jdbc:mariadb://" + host + ":" + port + "/" + database);
@ -53,7 +53,8 @@ public class SQLConnection extends PlexBase
dataSource.setPassword(password);
Plex.get().setStorageType(StorageType.MARIADB);
}
} catch (ClassNotFoundException throwables)
}
catch (ClassNotFoundException throwables)
{
throwables.printStackTrace();
}
@ -90,7 +91,13 @@ public class SQLConnection extends PlexBase
"`note` VARCHAR(2000), " +
"`timestamp` BIGINT" +
");").execute();
} catch (SQLException throwables)
con.prepareStatement("CREATE TABLE IF NOT EXISTS `permissions` (" +
"`uuid` VARCHAR(46) NOT NULL," +
"`permission` VARCHAR(1000) NOT NULL," +
"`allowed` BOOLEAN" +
");").execute();
}
catch (SQLException throwables)
{
throwables.printStackTrace();
}
@ -105,7 +112,8 @@ public class SQLConnection extends PlexBase
try
{
return dataSource.getConnection();
} catch (SQLException e)
}
catch (SQLException e)
{
e.printStackTrace();
}

View File

@ -0,0 +1,95 @@
package dev.plex.storage.permission;
import com.google.common.collect.Lists;
import dev.plex.Plex;
import dev.plex.permission.Permission;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Locale;
import java.util.UUID;
public class SQLPermissions
{
private static final String SELECT = "SELECT * FROM `permissions` WHERE uuid=?";
private static final String INSERT = "INSERT INTO `permissions` (`uuid`, `permission`, `allowed`) VALUES(?, ?, ?)";
private static final String REMOVE_PERMISSION = "DELETE FROM `permissions` WHERE uuid=? AND permission=?";
private static final String UPDATE_PERMISSION = "UPDATE `permissions` SET allowed=? WHERE uuid=? AND permission=?";
public List<Permission> getPermissions(UUID uuid)
{
List<Permission> permissions = Lists.newArrayList();
try (Connection con = Plex.get().getSqlConnection().getCon())
{
PreparedStatement statement = con.prepareStatement(SELECT);
statement.setString(1, uuid.toString());
ResultSet set = statement.executeQuery();
while (set.next())
{
Permission permission = new Permission(UUID.fromString(set.getString("uuid")), set.getString("permission"));
permission.setAllowed(set.getBoolean("allowed"));
permissions.add(permission);
}
}
catch (SQLException e)
{
e.printStackTrace();
}
return permissions;
}
public void addPermission(Permission permission)
{
try (Connection con = Plex.get().getSqlConnection().getCon())
{
PreparedStatement statement = con.prepareStatement(INSERT);
statement.setString(1, permission.getUuid().toString());
statement.setString(2, permission.getPermission().toLowerCase(Locale.ROOT));
statement.setBoolean(3, permission.isAllowed());
statement.execute();
}
catch (SQLException e)
{
e.printStackTrace();
}
}
public void updatePermission(Permission permission, boolean newValue)
{
try (Connection con = Plex.get().getSqlConnection().getCon())
{
PreparedStatement statement = con.prepareStatement(UPDATE_PERMISSION);
statement.setBoolean(1, newValue);
statement.setString(2, permission.getUuid().toString());
statement.setString(3, permission.getPermission().toLowerCase(Locale.ROOT));
statement.executeUpdate();
}
catch (SQLException e)
{
e.printStackTrace();
}
}
public void removePermission(Permission permission)
{
this.removePermission(permission.getUuid(), permission.getPermission());
}
public void removePermission(UUID uuid, String permission)
{
try (Connection con = Plex.get().getSqlConnection().getCon())
{
PreparedStatement statement = con.prepareStatement(REMOVE_PERMISSION);
statement.setString(1, uuid.toString());
statement.setString(2, permission.toLowerCase(Locale.ROOT));
statement.execute();
}
catch (SQLException e)
{
e.printStackTrace();
}
}
}

View File

@ -1,4 +1,4 @@
package dev.plex.cache.player;
package dev.plex.storage.player;
import dev.morphia.Datastore;
import dev.morphia.query.Query;
@ -6,6 +6,7 @@ import dev.morphia.query.Update;
import dev.morphia.query.experimental.filters.Filters;
import dev.morphia.query.experimental.updates.UpdateOperators;
import dev.plex.Plex;
import dev.plex.cache.PlayerCache;
import dev.plex.player.PlexPlayer;
import java.util.Collections;
import java.util.List;
@ -43,6 +44,14 @@ public class MongoPlayerData
return query.first() != null;
}
public boolean exists(String username)
{
Query<PlexPlayer> query = datastore.find(PlexPlayer.class)
.filter(Filters.regex("name").caseInsensitive().pattern(username));
return query.first() != null;
}
/**
* Gets the player from cache or from mongo's database
*

View File

@ -1,8 +1,9 @@
package dev.plex.cache.player;
package dev.plex.storage.player;
import com.google.common.reflect.TypeToken;
import com.google.gson.Gson;
import dev.plex.Plex;
import dev.plex.cache.PlayerCache;
import dev.plex.player.PlexPlayer;
import java.sql.Connection;
import java.sql.PreparedStatement;
@ -42,6 +43,22 @@ public class SQLPlayerData
return false;
}
public boolean exists(String username)
{
try (Connection con = Plex.get().getSqlConnection().getCon())
{
PreparedStatement statement = con.prepareStatement("SELECT * FROM `players` WHERE name=?");
statement.setString(1, username);
ResultSet set = statement.executeQuery();
return set.next();
}
catch (SQLException throwables)
{
throwables.printStackTrace();
}
return false;
}
/**
* Gets the player from cache or from the SQL database
*

View File

@ -1,9 +1,8 @@
package dev.plex.cache.sql;
package dev.plex.storage.punishment;
import com.google.common.collect.Lists;
import dev.plex.Plex;
import dev.plex.punishment.extra.Note;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
@ -47,6 +46,7 @@ public class SQLNotes
catch (SQLException e)
{
e.printStackTrace();
return notes;
}
return notes;
});

View File

@ -1,4 +1,4 @@
package dev.plex.cache.sql;
package dev.plex.storage.punishment;
import com.google.common.collect.Lists;
import dev.plex.Plex;
@ -36,7 +36,7 @@ public class SQLPunishment
ResultSet set = statement.executeQuery();
while (set.next())
{
Punishment punishment = new Punishment(UUID.fromString(set.getString("punished")), UUID.fromString(set.getString("punisher")));
Punishment punishment = new Punishment(UUID.fromString(set.getString("punished")), set.getString("punisher") != null && set.getString("punisher").isEmpty() ? UUID.fromString(set.getString("punisher")) : null);
punishment.setActive(set.getBoolean("active"));
punishment.setType(PunishmentType.valueOf(set.getString("type")));
punishment.setCustomTime(set.getBoolean("customTime"));
@ -50,6 +50,7 @@ public class SQLPunishment
catch (SQLException e)
{
e.printStackTrace();
return punishments;
}
return punishments;
});
@ -111,6 +112,22 @@ public class SQLPunishment
});
}
public void syncRemoveBan(UUID uuid)
{
try (Connection con = Plex.get().getSqlConnection().getCon())
{
PreparedStatement statement = con.prepareStatement(UPDATE_BAN);
statement.setBoolean(1, false);
statement.setBoolean(2, true);
statement.setString(3, uuid.toString());
statement.setString(4, PunishmentType.BAN.name());
}
catch (SQLException e)
{
e.printStackTrace();
}
}
public CompletableFuture<Void> removeBan(UUID uuid)
{
return CompletableFuture.runAsync(() ->

View File

@ -4,21 +4,12 @@ import com.google.common.collect.ImmutableSet;
import com.google.common.reflect.ClassPath;
import dev.plex.Plex;
import dev.plex.PlexBase;
import dev.plex.cache.DataUtils;
import dev.plex.cache.PlayerCache;
import dev.plex.config.Config;
import dev.plex.permission.Permission;
import dev.plex.player.PlexPlayer;
import dev.plex.storage.StorageType;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.minimessage.MiniMessage;
import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
import org.apache.commons.lang.math.NumberUtils;
import org.bukkit.*;
import org.bukkit.command.Command;
import org.bukkit.command.PluginCommandYamlParser;
import org.bukkit.entity.Player;
import org.bukkit.plugin.Plugin;
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;
import org.json.simple.parser.ParseException;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
@ -28,10 +19,46 @@ import java.sql.Connection;
import java.sql.SQLException;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.Month;
import java.time.ZoneId;
import java.util.*;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.TimeZone;
import java.util.UUID;
import java.util.concurrent.ThreadLocalRandom;
import java.util.stream.Collectors;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.minimessage.MiniMessage;
import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
import net.kyori.adventure.text.minimessage.tag.standard.StandardTags;
import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
import org.apache.commons.lang.math.NumberUtils;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.GameRule;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.Particle;
import org.bukkit.World;
import org.bukkit.command.Command;
import org.bukkit.command.PluginCommandYamlParser;
import org.bukkit.entity.Player;
import org.bukkit.permissions.PermissionAttachment;
import org.bukkit.plugin.Plugin;
import org.jetbrains.annotations.NotNull;
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;
import org.json.simple.parser.ParseException;
public class PlexUtils extends PlexBase
{
@ -54,6 +81,9 @@ public class PlexUtils extends PlexBase
"ca83b658-c03b-4106-9edc-72f70a80656d", // ayunami2000
"2e06e049-24c8-42e4-8bcf-d35372af31e6" //Fleek
);
private static final DateTimeFormatter DATE_FORMAT = DateTimeFormatter.ofPattern("MM/dd/yyyy 'at' hh:mm:ss a z");
private static final Set<String> TIMEZONES = Set.of(TimeZone.getAvailableIDs());
private static String TIMEZONE = Plex.get().config.getString("server.timezone");
static
{
@ -66,6 +96,64 @@ public class PlexUtils extends PlexBase
}
}
public static void setupPermissions(@NotNull Player player)
{
PlexPlayer plexPlayer = DataUtils.getPlayer(player.getUniqueId());
PermissionAttachment attachment = player.addAttachment(Plex.get());
plexPlayer.getPermissions().forEach(permission -> attachment.setPermission(permission.getPermission(), permission.isAllowed()));
plexPlayer.setPermissionAttachment(attachment);
}
public static void addPermission(PlexPlayer player, Permission permission)
{
Plex.get().getSqlPermissions().addPermission(addToArrayList(player.getPermissions(), permission));
Player p = Bukkit.getPlayer(player.getUuid());
if (p == null)
{
return;
}
player.getPermissionAttachment().setPermission(permission.getPermission(), permission.isAllowed());
}
public static void addPermission(PlexPlayer player, String permission)
{
addPermission(player, new Permission(player.getUuid(), permission));
}
public static void removePermission(PlexPlayer player, String permission)
{
Plex.get().getSqlPermissions().removePermission(player.getUuid(), permission);
player.getPermissions().removeIf(permission1 -> permission1.getPermission().equalsIgnoreCase(permission));
Player p = Bukkit.getPlayer(player.getUuid());
if (p == null)
{
return;
}
player.getPermissionAttachment().unsetPermission(permission);
}
public static void updatePermission(PlexPlayer player, String permission, boolean newValue)
{
player.getPermissions().stream().filter(permission1 -> permission.equalsIgnoreCase(permission)).findFirst().ifPresent(permission1 ->
{
Plex.get().getSqlPermissions().updatePermission(permission1, newValue);
});
player.getPermissions().removeIf(permission1 -> permission1.getPermission().equalsIgnoreCase(permission));
Player p = Bukkit.getPlayer(player.getUuid());
if (p == null)
{
return;
}
player.getPermissionAttachment().unsetPermission(permission);
}
public static <T> T addToArrayList(List<T> list, T object)
{
list.add(object);
return object;
}
public static void disabledEffect(Player player, Location location)
{
Particle.CLOUD.builder().location(location).receivers(player).extra(0).offset(0.5, 0.5, 0.5).count(5).spawn();
@ -145,6 +233,40 @@ public class PlexUtils extends PlexBase
return ChatColor.translateAlternateColorCodes('&', string);
}
private static final MiniMessage safeMessage = MiniMessage.builder().tags(TagResolver.builder().resolvers(
StandardTags.color(),
StandardTags.decorations(),
StandardTags.gradient(),
StandardTags.rainbow(),
StandardTags.reset()
).build()).build();
public static String mmStripColor(String input)
{
return PlainTextComponentSerializer.plainText().serialize(mmDeserialize(input));
}
public static Component mmDeserialize(String input)
{
boolean aprilFools = true; // true by default
if (plugin.config.contains("april_fools"))
{
aprilFools = plugin.config.getBoolean("april_fools");
}
LocalDateTime date = LocalDateTime.now();
if (aprilFools && date.getMonth() == Month.APRIL && date.getDayOfMonth() == 1)
{
Component component = MiniMessage.miniMessage().deserialize(input); // removes existing tags
return MiniMessage.miniMessage().deserialize("<rainbow>" + PlainTextComponentSerializer.plainText().serialize(component));
}
return MiniMessage.miniMessage().deserialize(input);
}
public static Component mmCustomDeserialize(String input, TagResolver... resolvers)
{
return MiniMessage.builder().tags(TagResolver.builder().resolvers(resolvers).build()).build().deserialize(input);
}
public static Component messageComponent(String entry, Object... objects)
{
return MiniMessage.miniMessage().deserialize(messageString(entry, objects));
@ -202,6 +324,16 @@ public class PlexUtils extends PlexBase
return (unit != null) ? unit : TimeUnit.DAY;
}
public static String useTimezone(LocalDateTime date)
{
// Use UTC if the timezone is null or not set correctly
if (TIMEZONE == null || !TIMEZONES.contains(TIMEZONE))
{
TIMEZONE = "Etc/UTC";
}
return DATE_FORMAT.withZone(ZoneId.of(TIMEZONE)).format(date);
}
public static LocalDateTime parseDateOffset(String... time)
{
Instant instant = Instant.now();
@ -303,7 +435,7 @@ public class PlexUtils extends PlexBase
public static void broadcast(String s)
{
Bukkit.broadcast(LegacyComponentSerializer.legacyAmpersand().deserialize(s));
Bukkit.broadcast(MiniMessage.miniMessage().deserialize(s));
}
public static void broadcast(Component component)
@ -311,6 +443,12 @@ public class PlexUtils extends PlexBase
Bukkit.broadcast(component);
}
public static void broadcastToAdmins(Component component)
{
Bukkit.getOnlinePlayers().stream().filter(pl -> PlayerCache.getPlexPlayer(pl.getUniqueId()).isAdminActive()).forEach(pl ->
Bukkit.broadcast(component));
}
public static Object simpleGET(String url)
{
try

View File

@ -6,9 +6,17 @@ import com.google.gson.JsonObject;
import com.google.gson.JsonSyntaxException;
import dev.plex.Plex;
import dev.plex.PlexBase;
import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.CompletableFuture;
import javax.annotation.Nonnull;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.format.NamedTextColor;
import net.kyori.adventure.text.minimessage.MiniMessage;
import org.apache.commons.io.FileUtils;
import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpGet;
@ -19,16 +27,6 @@ import org.bukkit.Bukkit;
import org.bukkit.command.CommandSender;
import org.json.JSONObject;
import javax.annotation.Nonnull;
import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.CompletableFuture;
public class UpdateChecker extends PlexBase
{
/*
@ -114,28 +112,32 @@ public class UpdateChecker extends PlexBase
switch (distance)
{
case -1 -> {
case -1 ->
{
if (verbosity == 2)
{
sender.sendMessage(Component.text("There was an error checking for updates.").color(NamedTextColor.RED));
}
return false;
}
case 0 -> {
case 0 ->
{
if (verbosity == 2)
{
sender.sendMessage(Component.text("Plex is up to date!").color(NamedTextColor.GREEN));
}
return false;
}
case -2 -> {
case -2 ->
{
if (verbosity == 2)
{
sender.sendMessage(Component.text("Unknown version, unable to check for updates.").color(NamedTextColor.RED));
}
return false;
}
default -> {
default ->
{
if (verbosity >= 1)
{
sender.sendMessage(Component.text("Plex is not up to date!", NamedTextColor.RED));
@ -147,11 +149,6 @@ public class UpdateChecker extends PlexBase
}
}
private void sendMini(CommandSender sender, String message)
{
sender.sendMessage(MiniMessage.miniMessage().deserialize(message));
}
public void updateJar(CommandSender sender)
{
CloseableHttpClient client = HttpClients.createDefault();
@ -162,7 +159,7 @@ public class UpdateChecker extends PlexBase
JSONObject object = new JSONObject(EntityUtils.toString(response.getEntity(), StandardCharsets.UTF_8));
JSONObject artifact = object.getJSONArray("artifacts").getJSONObject(0);
String name = artifact.getString("fileName");
sendMini(sender, "<green>Downloading latest Plex jar file: " + name);
sender.sendMessage(PlexUtils.mmDeserialize("<green>Downloading latest Plex jar file: " + name));
CompletableFuture.runAsync(() ->
{
try
@ -171,7 +168,7 @@ public class UpdateChecker extends PlexBase
new URL(DOWNLOAD_PAGE + "job/" + branch + "/lastSuccessfulBuild/artifact/build/libs/" + name),
new File(Bukkit.getUpdateFolderFile(), name)
);
sendMini(sender, "<green>Saved new jar. Please restart your server.");
sender.sendMessage(PlexUtils.mmDeserialize("<green>Saved new jar. Please restart your server."));
}
catch (IOException e)
{

View File

@ -1,5 +1,6 @@
package dev.plex.util.item;
import java.util.Arrays;
import net.kyori.adventure.text.Component;
import org.bukkit.Material;
import org.bukkit.attribute.Attribute;
@ -9,8 +10,6 @@ import org.bukkit.inventory.ItemFlag;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
import java.util.Arrays;
public class ItemBuilder
{

View File

@ -14,8 +14,8 @@
#
# So these would be valid:
# - "m:e:mail sendall:You cannot send messages to everyone on the server"
# - "r:e:(.*:):Plugin specific commands are disabled"
# - "r:e:^[^ :]+::Plugin specific commands are disabled"
blockedCommands:
- "r:e:^[^ :]+::Plugin specific commands are disabled."
- "m:e:mail sendall:You cannot send messages to everyone on the server."
- "m:e:mail sendtempall:You cannot send messages to everyone on the server."
- "r:e:^[^ :]+::<gray>Plugin specific commands are disabled."
- "m:e:mail sendall:<gray>You cannot send messages to everyone on the server."
- "m:e:mail sendtempall:<gray>You cannot send messages to everyone on the server."

View File

@ -7,6 +7,8 @@ server:
colorize_motd: true
sample:
- "&cForums: https://forum.plex.us.org"
# What timezone should various messages appear in (e.g. ban message end date)
timezone: Etc/UTC
titles:
masterbuilders: [ ]
@ -24,8 +26,8 @@ chat:
# The maximum amount of characters a player can have for their tag
# This does not include color tags such as <red> or <rainbow>
max-tag-length: 64
# Color code for name color
name-color: 'f'
# Color tag for name color
name-color: '<white>'
# Should Plex use a "true op" system with ranks or only permission nodes
# Options are "permissions" or "ranks"
@ -139,13 +141,13 @@ autowipe:
allowdrops: true
# What blocks should be blocked?
blockedBlocks:
blocked_blocks:
- "SPAWNER"
- "STRUCTURE_BLOCK"
- "JIGSAW"
# What entities should be blocked?
blockedEntities:
blocked_entities:
- "WITHER"
- "ENDER_DRAGON"
- "MINECART_TNT"

View File

@ -167,5 +167,10 @@ removedMobs: "<red>{0} - Removed {1} mobs"
autoWipeDisabled: "<gray>Item wiping is currently disabled in the config!"
allowDropsDisabled: "<gray>No longer allowing drops from players."
allowDropsEnabled: "<gray>Now allowing drops from players."
blockedCommandColor: "<gray>"
commandBlocked: "That command is blocked."
commandBlocked: "<gray>That command is blocked."
# 0 - The command sender
# 1 - The message being said
sayMessage: "<blue>[Server: {0}] {1}"
# 0 - The command sender
# 1 - The message being said
consoleSayMessage: "<gray>[Console: {0}] <white>{1}"