diff --git a/common/src/main/java/me/lucko/luckperms/commands/CommandManager.java b/common/src/main/java/me/lucko/luckperms/commands/CommandManager.java index 96b139c2b..834686954 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/CommandManager.java +++ b/common/src/main/java/me/lucko/luckperms/commands/CommandManager.java @@ -114,7 +114,7 @@ public class CommandManager { } final MainCommand main = o.get(); - if (!main.canUse(sender)) { + if (!main.isAuthorized(sender)) { sendCommandUsage(sender, label); return true; } @@ -140,8 +140,9 @@ public class CommandManager { * @param args the arguments provided so far * @return a list of suggestions */ + @SuppressWarnings("unchecked") public List onTabComplete(Sender sender, List args) { - final List mains = mainCommands.stream().filter(m -> m.canUse(sender)).collect(Collectors.toList()); + final List mains = mainCommands.stream().filter(m -> m.isAuthorized(sender)).collect(Collectors.toList()); if (args.size() <= 1) { if (args.isEmpty() || args.get(0).equalsIgnoreCase("")) { @@ -169,7 +170,7 @@ public class CommandManager { Message.INFO_BRIEF.send(sender, plugin.getVersion()); mainCommands.stream() - .filter(c -> c.canUse(sender)) + .filter(c -> c.isAuthorized(sender)) .forEach(c -> Util.sendPluginMessage(sender, "&e-> &d" + String.format(c.getUsage(), label))); } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/MainCommand.java b/common/src/main/java/me/lucko/luckperms/commands/MainCommand.java index 37c422d8b..8a60e836d 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/MainCommand.java +++ b/common/src/main/java/me/lucko/luckperms/commands/MainCommand.java @@ -1,27 +1,103 @@ package me.lucko.luckperms.commands; -import lombok.AllArgsConstructor; import lombok.Getter; +import lombok.RequiredArgsConstructor; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.api.data.Callback; import me.lucko.luckperms.constants.Message; +import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.Optional; import java.util.stream.Collectors; @Getter -@AllArgsConstructor -public abstract class MainCommand { +@RequiredArgsConstructor +public abstract class MainCommand { + /** + * The name of the main command + */ private final String name; + + /** + * The command usage + */ private final String usage; + + /** + * How many arguments are required for the command to run + */ private final int requiredArgsLength; - protected abstract void execute(LuckPermsPlugin plugin, Sender sender, List args, String label); - protected abstract List onTabComplete(Sender sender, List args, LuckPermsPlugin plugin); - public abstract List getSubCommands(); + /** + * A list of the sub commands under this main command + */ + @Getter + private final List> subCommands = new ArrayList<>(); + /** + * Called when this main command is ran + * @param plugin a link to the main plugin instance + * @param sender the sender to executed the command + * @param args the stripped arguments given + * @param label the command label used + */ + protected void execute(LuckPermsPlugin plugin, Sender sender, List args, String label) { + if (args.size() < 2) { + sendUsage(sender, label); + return; + } + + Optional> o = subCommands.stream().filter(s -> s.getName().equalsIgnoreCase(args.get(1))).limit(1).findAny(); + + if (!o.isPresent()) { + Message.COMMAND_NOT_RECOGNISED.send(sender); + return; + } + + final SubCommand sub = o.get(); + if (!sub.isAuthorized(sender)) { + Message.COMMAND_NO_PERMISSION.send(sender); + return; + } + + List strippedArgs = new ArrayList<>(); + if (args.size() > 2) { + strippedArgs.addAll(args.subList(2, args.size())); + } + + if (sub.getIsArgumentInvalid().test(strippedArgs.size())) { + sub.sendUsage(sender, label); + return; + } + + final String name = args.get(0).toLowerCase(); + getTarget(name, plugin, sender, t -> sub.execute(plugin, sender, t, strippedArgs, label)); + } + + /** + * Gets the object the command is acting upon, and runs the callback if successful + * @param target the name of the object to be looked up + * @param plugin a link to the main plugin instance + * @param sender the user who send the command (used to send error messages if the lookup was unsuccessful) + * @param onSuccess the callback to run when the lookup is completed + */ + protected abstract void getTarget(String target, LuckPermsPlugin plugin, Sender sender, Callback onSuccess); + + /** + * Get a list of objects for tab completion + * @param plugin a link to the main plugin instance + * @return a list of strings + */ + protected abstract List getObjects(LuckPermsPlugin plugin); + + /** + * Send the command usage to a sender + * @param sender the sender to send the usage to + * @param label the command label used + */ protected void sendUsage(Sender sender, String label) { if (getSubCommands().isEmpty()) { Util.sendPluginMessage(sender, "&e-> &d" + String.format(getUsage(), label)); @@ -41,12 +117,27 @@ public abstract class MainCommand { } } - protected boolean canUse(Sender sender) { + /** + * If a sender has permission to use this command + * @param sender the sender trying to use the command + * @return true if the sender can use the command + */ + protected boolean isAuthorized(Sender sender) { return getSubCommands().stream().filter(sc -> sc.isAuthorized(sender)).count() != 0; } - protected List onAbstractTabComplete(Sender sender, List args, LuckPermsPlugin plugin) { - final List subs = getSubCommands().stream().filter(s -> s.isAuthorized(sender)).collect(Collectors.toList()); + protected List onTabComplete(Sender sender, List args, LuckPermsPlugin plugin) { + final List objects = getObjects(plugin); + + if (args.size() <= 1) { + if (args.isEmpty() || args.get(0).equalsIgnoreCase("")) { + return objects; + } + + return objects.stream().filter(s -> s.toLowerCase().startsWith(args.get(0).toLowerCase())).collect(Collectors.toList()); + } + + final List> subs = getSubCommands().stream().filter(s -> s.isAuthorized(sender)).collect(Collectors.toList()); if (args.size() == 2) { if (args.get(1).equalsIgnoreCase("")) { return subs.stream().map(SubCommand::getName).map(String::toLowerCase).collect(Collectors.toList()); @@ -56,11 +147,15 @@ public abstract class MainCommand { .filter(s -> s.toLowerCase().startsWith(args.get(1).toLowerCase())).collect(Collectors.toList()); } - Optional o = subs.stream().filter(s -> s.getName().equalsIgnoreCase(args.get(1))).limit(1).findAny(); + Optional> o = subs.stream().filter(s -> s.getName().equalsIgnoreCase(args.get(1))).limit(1).findAny(); if (!o.isPresent()) { return Collections.emptyList(); } return o.get().onTabComplete(sender, args.subList(2, args.size()), plugin); } + + public void registerSubCommand(SubCommand subCommand) { + subCommands.add(subCommand); + } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/Predicate.java b/common/src/main/java/me/lucko/luckperms/commands/Predicate.java new file mode 100644 index 000000000..a694e3833 --- /dev/null +++ b/common/src/main/java/me/lucko/luckperms/commands/Predicate.java @@ -0,0 +1,43 @@ +package me.lucko.luckperms.commands; + +import lombok.experimental.UtilityClass; + +import java.util.stream.IntStream; + +@UtilityClass +public class Predicate { + public static java.util.function.Predicate alwaysFalse() { + return t -> false; + } + + public static java.util.function.Predicate alwaysTrue() { + return t -> true; + } + + public static java.util.function.Predicate notinRange(Integer start, Integer end) { + return inverse(inRange(start, end)); + } + + public static java.util.function.Predicate inRange(Integer start, Integer end) { + return isOneOf(IntStream.rangeClosed(start, end).boxed().toArray(Integer[]::new)); + } + + public static java.util.function.Predicate notOneOf(T[] ts) { + return inverse(isOneOf(ts)); + } + + public static java.util.function.Predicate isOneOf(T[] ta) { + return t -> { + for (T i : ta) { + if (i == t) { + return true; + } + } + return false; + }; + } + + public static java.util.function.Predicate inverse(java.util.function.Predicate t) { + return t2 -> !t.test(t2); + } +} diff --git a/common/src/main/java/me/lucko/luckperms/commands/SingleMainCommand.java b/common/src/main/java/me/lucko/luckperms/commands/SingleMainCommand.java new file mode 100644 index 000000000..224f4399b --- /dev/null +++ b/common/src/main/java/me/lucko/luckperms/commands/SingleMainCommand.java @@ -0,0 +1,36 @@ +package me.lucko.luckperms.commands; + +import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.api.data.Callback; + +import java.util.Collections; +import java.util.List; + +/** + * An extension of {@link MainCommand} for implementations without any subcommands + */ +public class SingleMainCommand extends MainCommand { + public SingleMainCommand(String name, String usage, int requiredArgsLength) { + super(name, usage, requiredArgsLength); + } + + @Override + protected void getTarget(String target, LuckPermsPlugin plugin, Sender sender, Callback onSuccess) { + + } + + @Override + protected List getObjects(LuckPermsPlugin plugin) { + return Collections.emptyList(); + } + + @Override + protected List onTabComplete(Sender sender, List args, LuckPermsPlugin plugin) { + return Collections.emptyList(); + } + + @Override + public List> getSubCommands() { + return Collections.emptyList(); + } +} diff --git a/common/src/main/java/me/lucko/luckperms/commands/SubCommand.java b/common/src/main/java/me/lucko/luckperms/commands/SubCommand.java index c9e773b23..8d9f8d101 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/SubCommand.java +++ b/common/src/main/java/me/lucko/luckperms/commands/SubCommand.java @@ -3,44 +3,78 @@ package me.lucko.luckperms.commands; import lombok.AllArgsConstructor; import lombok.Getter; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; +import me.lucko.luckperms.groups.Group; +import me.lucko.luckperms.tracks.Track; import me.lucko.luckperms.users.User; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.List; +import java.util.function.Predicate; import java.util.stream.Collectors; /** * Abstract SubCommand class - * Doesn't declare any abstract onCommand methods, as sub classes declare their own with parameters unique to the sub command type. - * For example, see: {@link me.lucko.luckperms.commands.user.UserSubCommand#execute(LuckPermsPlugin, Sender, User, List, String)} - * - * SubCommand #execute methods are always called from the {@link MainCommand} class related to them, so abstraction is not needed. */ @Getter @AllArgsConstructor -public abstract class SubCommand { +public abstract class SubCommand { + + /** + * The name of the sub command + */ private final String name; + + /** + * A brief description of what the sub command does + */ private final String description; + + /** + * The command usage + */ private final String usage; + + /** + * The permission needed to use this command + */ private final Permission permission; - public abstract boolean isArgLengthInvalid(int argLength); + /** + * Predicate to test if the argument length given is invalid + */ + private final Predicate isArgumentInvalid; - public boolean isAuthorized(Sender sender) { - return permission.isAuthorized(sender); - } + /** + * Called when this sub command is ran + * @param plugin a link to the main plugin instance + * @param sender the sender to executed the command + * @param t the object the command is operating on + * @param args the stripped arguments given + * @param label the command label used + */ + public abstract void execute(LuckPermsPlugin plugin, Sender sender, T t, List args, String label); + /** + * Send the command usage to a sender + * @param sender the sender to send the usage to + * @param label the command label used + */ public void sendUsage(Sender sender, String label) { Util.sendPluginMessage(sender, "&e-> &d" + String.format(getUsage(), label)); } - /* - * Returns a list of suggestions, which are empty by default. Sub classes that give tab complete suggestions override - * this method to give their own list. + /** + * If a sender has permission to use this command + * @param sender the sender trying to use the command + * @return true if the sender can use the command */ + public boolean isAuthorized(Sender sender) { + return permission.isAuthorized(sender); + } /** * Returns a list of suggestions, which are empty by default. Sub classes that give tab complete suggestions override @@ -54,7 +88,12 @@ public abstract class SubCommand { return Collections.emptyList(); } - /* Utility methods used by #onTabComplete implementations in sub classes */ + /* + ---------------------------------------------------------------------------------- + Utility methods used by #onTabComplete and #execute implementations in sub classes + ---------------------------------------------------------------------------------- + */ + protected static List getGroupTabComplete(List args, LuckPermsPlugin plugin) { return getTabComplete(new ArrayList<>(plugin.getGroupManager().getGroups().keySet()), args); } @@ -82,4 +121,40 @@ public abstract class SubCommand { return Collections.emptyList(); } + + protected static void saveUser(User user, Sender sender, LuckPermsPlugin plugin) { + user.refreshPermissions(); + + plugin.getDatastore().saveUser(user, success -> { + if (success) { + Message.USER_SAVE_SUCCESS.send(sender); + } else { + Message.USER_SAVE_ERROR.send(sender); + } + }); + } + + protected static void saveGroup(Group group, Sender sender, LuckPermsPlugin plugin) { + plugin.getDatastore().saveGroup(group, success -> { + if (success) { + Message.GROUP_SAVE_SUCCESS.send(sender); + } else { + Message.GROUP_SAVE_ERROR.send(sender); + } + + plugin.runUpdateTask(); + }); + } + + protected static void saveTrack(Track track, Sender sender, LuckPermsPlugin plugin) { + plugin.getDatastore().saveTrack(track, success -> { + if (success) { + Message.TRACK_SAVE_SUCCESS.send(sender); + } else { + Message.TRACK_SAVE_ERROR.send(sender); + } + + plugin.runUpdateTask(); + }); + } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/group/CreateGroup.java b/common/src/main/java/me/lucko/luckperms/commands/group/CreateGroup.java index a0d812f91..0d2c958a9 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/group/CreateGroup.java +++ b/common/src/main/java/me/lucko/luckperms/commands/group/CreateGroup.java @@ -1,17 +1,15 @@ package me.lucko.luckperms.commands.group; import me.lucko.luckperms.LuckPermsPlugin; -import me.lucko.luckperms.commands.MainCommand; import me.lucko.luckperms.commands.Sender; -import me.lucko.luckperms.commands.SubCommand; +import me.lucko.luckperms.commands.SingleMainCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.utils.Patterns; -import java.util.Collections; import java.util.List; -public class CreateGroup extends MainCommand { +public class CreateGroup extends SingleMainCommand { public CreateGroup() { super("CreateGroup", "/%s creategroup ", 1); } @@ -52,17 +50,7 @@ public class CreateGroup extends MainCommand { } @Override - protected List onTabComplete(Sender sender, List args, LuckPermsPlugin plugin) { - return Collections.emptyList(); - } - - @Override - public List getSubCommands() { - return Collections.emptyList(); - } - - @Override - protected boolean canUse(Sender sender) { + protected boolean isAuthorized(Sender sender) { return Permission.CREATE_GROUP.isAuthorized(sender); } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/group/DeleteGroup.java b/common/src/main/java/me/lucko/luckperms/commands/group/DeleteGroup.java index b475ec088..53b4a37a6 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/group/DeleteGroup.java +++ b/common/src/main/java/me/lucko/luckperms/commands/group/DeleteGroup.java @@ -1,9 +1,8 @@ package me.lucko.luckperms.commands.group; import me.lucko.luckperms.LuckPermsPlugin; -import me.lucko.luckperms.commands.MainCommand; import me.lucko.luckperms.commands.Sender; -import me.lucko.luckperms.commands.SubCommand; +import me.lucko.luckperms.commands.SingleMainCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.groups.Group; @@ -14,7 +13,7 @@ import java.util.Collections; import java.util.List; import java.util.stream.Collectors; -public class DeleteGroup extends MainCommand { +public class DeleteGroup extends SingleMainCommand { public DeleteGroup() { super("DeleteGroup", "/%s deletegroup ", 1); } @@ -76,12 +75,7 @@ public class DeleteGroup extends MainCommand { } @Override - public List getSubCommands() { - return Collections.emptyList(); - } - - @Override - protected boolean canUse(Sender sender) { + protected boolean isAuthorized(Sender sender) { return Permission.DELETE_GROUP.isAuthorized(sender); } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/group/GroupMainCommand.java b/common/src/main/java/me/lucko/luckperms/commands/group/GroupMainCommand.java index 5b570ed66..bf313868e 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/group/GroupMainCommand.java +++ b/common/src/main/java/me/lucko/luckperms/commands/group/GroupMainCommand.java @@ -1,101 +1,46 @@ package me.lucko.luckperms.commands.group; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.api.data.Callback; import me.lucko.luckperms.commands.MainCommand; import me.lucko.luckperms.commands.Sender; -import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.groups.Group; import me.lucko.luckperms.utils.Patterns; import java.util.ArrayList; import java.util.List; -import java.util.Optional; -import java.util.stream.Collectors; - -public class GroupMainCommand extends MainCommand { - - private final List subCommands = new ArrayList<>(); +public class GroupMainCommand extends MainCommand { public GroupMainCommand() { super("Group", "/%s group ", 2); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, List args, String label) { - if (args.size() < 2) { - sendUsage(sender, label); - return; - } - - Optional o = subCommands.stream().filter(s -> s.getName().equalsIgnoreCase(args.get(1))).limit(1).findAny(); - - if (!o.isPresent()) { - Message.COMMAND_NOT_RECOGNISED.send(sender); - return; - } - - final GroupSubCommand sub = o.get(); - if (!sub.isAuthorized(sender)) { - Message.COMMAND_NO_PERMISSION.send(sender); - return; - } - - List strippedArgs = new ArrayList<>(); - if (args.size() > 2) { - strippedArgs.addAll(args.subList(2, args.size())); - } - - if (sub.isArgLengthInvalid(strippedArgs.size())) { - sub.sendUsage(sender, label); - return; - } - - final String groupName = args.get(0).toLowerCase(); - - if (Patterns.NON_ALPHA_NUMERIC.matcher(groupName).find()) { + protected void getTarget(String target, LuckPermsPlugin plugin, Sender sender, Callback onSuccess) { + if (Patterns.NON_ALPHA_NUMERIC.matcher(target).find()) { Message.GROUP_INVALID_ENTRY.send(sender); return; } - plugin.getDatastore().loadGroup(groupName, success -> { + plugin.getDatastore().loadGroup(target, success -> { if (!success) { Message.GROUP_NOT_FOUND.send(sender); return; } - Group group = plugin.getGroupManager().getGroup(groupName); + Group group = plugin.getGroupManager().getGroup(target); if (group == null) { Message.GROUP_NOT_FOUND.send(sender); return; } - sub.execute(plugin, sender, group, strippedArgs, label); + onSuccess.onComplete(group); }); } @Override - protected List onTabComplete(Sender sender, List args, LuckPermsPlugin plugin) { - final List groups = new ArrayList<>(plugin.getGroupManager().getGroups().keySet()); - - if (args.size() <= 1) { - if (args.isEmpty() || args.get(0).equalsIgnoreCase("")) { - return groups; - } - - return groups.stream().filter(s -> s.toLowerCase().startsWith(args.get(0).toLowerCase())).collect(Collectors.toList()); - } - - return onAbstractTabComplete(sender, args, plugin); + protected List getObjects(LuckPermsPlugin plugin) { + return new ArrayList<>(plugin.getGroupManager().getGroups().keySet()); } - - @Override - public List getSubCommands() { - return subCommands; - } - - public void registerSubCommand(GroupSubCommand subCommand) { - subCommands.add(subCommand); - } - } diff --git a/common/src/main/java/me/lucko/luckperms/commands/group/GroupSubCommand.java b/common/src/main/java/me/lucko/luckperms/commands/group/GroupSubCommand.java deleted file mode 100644 index 03988fed4..000000000 --- a/common/src/main/java/me/lucko/luckperms/commands/group/GroupSubCommand.java +++ /dev/null @@ -1,30 +0,0 @@ -package me.lucko.luckperms.commands.group; - -import me.lucko.luckperms.LuckPermsPlugin; -import me.lucko.luckperms.commands.Sender; -import me.lucko.luckperms.commands.SubCommand; -import me.lucko.luckperms.constants.Message; -import me.lucko.luckperms.constants.Permission; -import me.lucko.luckperms.groups.Group; - -import java.util.List; - -public abstract class GroupSubCommand extends SubCommand { - protected GroupSubCommand(String name, String description, String usage, Permission permission) { - super(name, description, usage, permission); - } - - protected abstract void execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label); - - protected void saveGroup(Group group, Sender sender, LuckPermsPlugin plugin) { - plugin.getDatastore().saveGroup(group, success -> { - if (success) { - Message.GROUP_SAVE_SUCCESS.send(sender); - } else { - Message.GROUP_SAVE_ERROR.send(sender); - } - - plugin.runUpdateTask(); - }); - } -} diff --git a/common/src/main/java/me/lucko/luckperms/commands/group/ListGroups.java b/common/src/main/java/me/lucko/luckperms/commands/group/ListGroups.java index 5117a7c30..acfbfdc7d 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/group/ListGroups.java +++ b/common/src/main/java/me/lucko/luckperms/commands/group/ListGroups.java @@ -1,18 +1,16 @@ package me.lucko.luckperms.commands.group; import me.lucko.luckperms.LuckPermsPlugin; -import me.lucko.luckperms.commands.MainCommand; import me.lucko.luckperms.commands.Sender; -import me.lucko.luckperms.commands.SubCommand; +import me.lucko.luckperms.commands.SingleMainCommand; import me.lucko.luckperms.commands.Util; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import java.util.ArrayList; -import java.util.Collections; import java.util.List; -public class ListGroups extends MainCommand { +public class ListGroups extends SingleMainCommand { public ListGroups() { super("ListGroups", "/%s listgroups", 0); } @@ -29,17 +27,7 @@ public class ListGroups extends MainCommand { } @Override - protected List onTabComplete(Sender sender, List args, LuckPermsPlugin plugin) { - return Collections.emptyList(); - } - - @Override - public List getSubCommands() { - return Collections.emptyList(); - } - - @Override - protected boolean canUse(Sender sender) { + protected boolean isAuthorized(Sender sender) { return Permission.LIST_GROUPS.isAuthorized(sender); } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupClear.java b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupClear.java index 264bbb424..317523366 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupClear.java +++ b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupClear.java @@ -1,29 +1,26 @@ package me.lucko.luckperms.commands.group.subcommands; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.Predicate; import me.lucko.luckperms.commands.Sender; -import me.lucko.luckperms.commands.group.GroupSubCommand; +import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.groups.Group; import java.util.List; -public class GroupClear extends GroupSubCommand { +public class GroupClear extends SubCommand { public GroupClear() { - super("clear", "Clears a groups permissions", "/%s group clear", Permission.GROUP_CLEAR); + super("clear", "Clears a groups permissions", "/%s group clear", Permission.GROUP_CLEAR, + Predicate.alwaysFalse()); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { + public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { group.clearNodes(); Message.CLEAR_SUCCESS.send(sender, group.getName()); saveGroup(group, sender, plugin); } - - @Override - public boolean isArgLengthInvalid(int argLength) { - return false; - } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupHasPerm.java b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupHasPerm.java index 62fc5facb..ad56ac317 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupHasPerm.java +++ b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupHasPerm.java @@ -1,9 +1,10 @@ package me.lucko.luckperms.commands.group.subcommands; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.Predicate; import me.lucko.luckperms.commands.Sender; +import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.commands.Util; -import me.lucko.luckperms.commands.group.GroupSubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.groups.Group; @@ -11,14 +12,15 @@ import me.lucko.luckperms.utils.Patterns; import java.util.List; -public class GroupHasPerm extends GroupSubCommand { +public class GroupHasPerm extends SubCommand { public GroupHasPerm() { super("haspermission", "Checks to see if a group has a certain permission node", - "/%s group haspermission [server] [world]", Permission.GROUP_HASPERMISSION); + "/%s group haspermission [server] [world]", Permission.GROUP_HASPERMISSION, + Predicate.notinRange(1, 3)); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { + public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { if (args.size() >= 2) { if (Patterns.NON_ALPHA_NUMERIC.matcher(args.get(1)).find()) { Message.SERVER_INVALID_ENTRY.send(sender); @@ -35,9 +37,4 @@ public class GroupHasPerm extends GroupSubCommand { Util.sendBoolean(sender, args.get(0), group.hasPermission(args.get(0), true, "global")); } } - - @Override - public boolean isArgLengthInvalid(int argLength) { - return argLength != 1 && argLength != 2 && argLength != 3; - } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupInfo.java b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupInfo.java index 5f2d01c44..c7abeeecd 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupInfo.java +++ b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupInfo.java @@ -1,27 +1,24 @@ package me.lucko.luckperms.commands.group.subcommands; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.Predicate; import me.lucko.luckperms.commands.Sender; -import me.lucko.luckperms.commands.group.GroupSubCommand; +import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.groups.Group; import java.util.List; -public class GroupInfo extends GroupSubCommand { +public class GroupInfo extends SubCommand { public GroupInfo() { - super("info", "Gives info about the group", "/%s group info", Permission.GROUP_INFO); + super("info", "Gives info about the group", "/%s group info", Permission.GROUP_INFO, + Predicate.alwaysFalse()); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { + public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { Message.GROUP_INFO.send(sender, group.getName(), group.getPermanentNodes().keySet().size(), group.getTemporaryNodes().keySet().size(), label, group.getName()); } - - @Override - public boolean isArgLengthInvalid(int argLength) { - return false; - } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupInheritsPerm.java b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupInheritsPerm.java index 0cb993ebe..2d6d01921 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupInheritsPerm.java +++ b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupInheritsPerm.java @@ -1,9 +1,10 @@ package me.lucko.luckperms.commands.group.subcommands; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.Predicate; import me.lucko.luckperms.commands.Sender; +import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.commands.Util; -import me.lucko.luckperms.commands.group.GroupSubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.groups.Group; @@ -11,14 +12,15 @@ import me.lucko.luckperms.utils.Patterns; import java.util.List; -public class GroupInheritsPerm extends GroupSubCommand { +public class GroupInheritsPerm extends SubCommand { public GroupInheritsPerm() { super("inheritspermission", "Checks to see if a group inherits a certain permission node", - "/%s group inheritspermission [server] [world]", Permission.GROUP_INHERITSPERMISSION); + "/%s group inheritspermission [server] [world]", Permission.GROUP_INHERITSPERMISSION, + Predicate.notinRange(1, 3)); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { + public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { if (args.size() >= 2) { if (Patterns.NON_ALPHA_NUMERIC.matcher(args.get(1)).find()) { Message.SERVER_INVALID_ENTRY.send(sender); @@ -35,9 +37,4 @@ public class GroupInheritsPerm extends GroupSubCommand { Util.sendBoolean(sender, args.get(0), group.inheritsPermission(args.get(0), true)); } } - - @Override - public boolean isArgLengthInvalid(int argLength) { - return argLength != 1 && argLength != 2 && argLength != 3; - } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupListNodes.java b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupListNodes.java index 267992fda..53c292e77 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupListNodes.java +++ b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupListNodes.java @@ -1,29 +1,25 @@ package me.lucko.luckperms.commands.group.subcommands; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.Predicate; import me.lucko.luckperms.commands.Sender; +import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.commands.Util; -import me.lucko.luckperms.commands.group.GroupSubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.groups.Group; import java.util.List; -public class GroupListNodes extends GroupSubCommand { +public class GroupListNodes extends SubCommand { public GroupListNodes() { super("listnodes", "Lists the permission nodes the group has", "/%s group listnodes", - Permission.GROUP_LISTNODES); + Permission.GROUP_LISTNODES, Predicate.alwaysFalse()); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { + public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { Message.LISTNODES.send(sender, group.getName(), Util.permNodesToString(group.getPermanentNodes())); Message.LISTNODES_TEMP.send(sender, group.getName(), Util.tempNodesToString(group.getTemporaryNodes())); } - - @Override - public boolean isArgLengthInvalid(int argLength) { - return false; - } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupSetInherit.java b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupSetInherit.java index 8009e49a2..8f5ef136f 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupSetInherit.java +++ b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupSetInherit.java @@ -1,8 +1,9 @@ package me.lucko.luckperms.commands.group.subcommands; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.Predicate; import me.lucko.luckperms.commands.Sender; -import me.lucko.luckperms.commands.group.GroupSubCommand; +import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.exceptions.ObjectAlreadyHasException; @@ -11,14 +12,15 @@ import me.lucko.luckperms.utils.Patterns; import java.util.List; -public class GroupSetInherit extends GroupSubCommand { +public class GroupSetInherit extends SubCommand { public GroupSetInherit() { super("setinherit", "Sets another group for this group to inherit permissions from", - "/%s group setinherit [server] [world]", Permission.GROUP_SETINHERIT); + "/%s group setinherit [server] [world]", Permission.GROUP_SETINHERIT, + Predicate.notinRange(1, 3)); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { + public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { String groupName = args.get(0).toLowerCase(); if (groupName.contains("/") || groupName.contains("$")) { @@ -64,9 +66,4 @@ public class GroupSetInherit extends GroupSubCommand { public List onTabComplete(Sender sender, List args, LuckPermsPlugin plugin) { return getGroupTabComplete(args, plugin); } - - @Override - public boolean isArgLengthInvalid(int argLength) { - return argLength != 1 && argLength != 2 && argLength != 3; - } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupSetPermission.java b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupSetPermission.java index 0e091e8f3..b1dcf7275 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupSetPermission.java +++ b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupSetPermission.java @@ -1,8 +1,9 @@ package me.lucko.luckperms.commands.group.subcommands; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.Predicate; import me.lucko.luckperms.commands.Sender; -import me.lucko.luckperms.commands.group.GroupSubCommand; +import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.exceptions.ObjectAlreadyHasException; @@ -11,14 +12,14 @@ import me.lucko.luckperms.utils.Patterns; import java.util.List; -public class GroupSetPermission extends GroupSubCommand { +public class GroupSetPermission extends SubCommand { public GroupSetPermission() { super("set", "Sets a permission for a group", "/%s group set [server] [world]", - Permission.GROUP_SETPERMISSION); + Permission.GROUP_SETPERMISSION, Predicate.notinRange(2, 4)); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { + public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { String node = args.get(0); String bool = args.get(1).toLowerCase(); @@ -71,9 +72,4 @@ public class GroupSetPermission extends GroupSubCommand { public List onTabComplete(Sender sender, List args, LuckPermsPlugin plugin) { return getBoolTabComplete(args); } - - @Override - public boolean isArgLengthInvalid(int argLength) { - return argLength != 2 && argLength != 3 && argLength != 4; - } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupSetTempInherit.java b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupSetTempInherit.java index 1d4a57371..69fa00592 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupSetTempInherit.java +++ b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupSetTempInherit.java @@ -1,8 +1,9 @@ package me.lucko.luckperms.commands.group.subcommands; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.Predicate; import me.lucko.luckperms.commands.Sender; -import me.lucko.luckperms.commands.group.GroupSubCommand; +import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.exceptions.ObjectAlreadyHasException; @@ -12,14 +13,15 @@ import me.lucko.luckperms.utils.Patterns; import java.util.List; -public class GroupSetTempInherit extends GroupSubCommand { +public class GroupSetTempInherit extends SubCommand { public GroupSetTempInherit() { super("settempinherit", "Sets another group for this group to inherit permissions from temporarily", - "/%s group settempinherit [server] [world]", Permission.GROUP_SET_TEMP_INHERIT); + "/%s group settempinherit [server] [world]", + Permission.GROUP_SET_TEMP_INHERIT, Predicate.notinRange(2, 4)); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { + public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { String groupName = args.get(0).toLowerCase(); if (groupName.contains("/") || groupName.contains("$")) { @@ -80,9 +82,4 @@ public class GroupSetTempInherit extends GroupSubCommand { public List onTabComplete(Sender sender, List args, LuckPermsPlugin plugin) { return getGroupTabComplete(args, plugin); } - - @Override - public boolean isArgLengthInvalid(int argLength) { - return argLength != 2 && argLength != 3 && argLength != 4; - } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupSetTempPermission.java b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupSetTempPermission.java index 469a54ab0..94716e33b 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupSetTempPermission.java +++ b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupSetTempPermission.java @@ -1,8 +1,9 @@ package me.lucko.luckperms.commands.group.subcommands; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.Predicate; import me.lucko.luckperms.commands.Sender; -import me.lucko.luckperms.commands.group.GroupSubCommand; +import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.exceptions.ObjectAlreadyHasException; @@ -12,14 +13,15 @@ import me.lucko.luckperms.utils.Patterns; import java.util.List; -public class GroupSetTempPermission extends GroupSubCommand { +public class GroupSetTempPermission extends SubCommand { public GroupSetTempPermission() { super("settemp", "Sets a temporary permission for a group", - "/%s group settemp [server] [world]", Permission.GROUP_SET_TEMP_PERMISSION); + "/%s group settemp [server] [world]", + Permission.GROUP_SET_TEMP_PERMISSION, Predicate.notinRange(3, 5)); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { + public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { String node = args.get(0); String bool = args.get(1).toLowerCase(); @@ -87,9 +89,4 @@ public class GroupSetTempPermission extends GroupSubCommand { public List onTabComplete(Sender sender, List args, LuckPermsPlugin plugin) { return getBoolTabComplete(args); } - - @Override - public boolean isArgLengthInvalid(int argLength) { - return argLength != 3 && argLength != 4 && argLength != 5; - } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupShowTracks.java b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupShowTracks.java index 4848928b5..32d7bf045 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupShowTracks.java +++ b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupShowTracks.java @@ -1,9 +1,10 @@ package me.lucko.luckperms.commands.group.subcommands; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.Predicate; import me.lucko.luckperms.commands.Sender; +import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.commands.Util; -import me.lucko.luckperms.commands.group.GroupSubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.groups.Group; @@ -12,13 +13,14 @@ import me.lucko.luckperms.tracks.Track; import java.util.List; import java.util.stream.Collectors; -public class GroupShowTracks extends GroupSubCommand { +public class GroupShowTracks extends SubCommand { public GroupShowTracks() { - super("showtracks", "Lists the tracks that this group features on", "/%s group showtracks", Permission.GROUP_SHOWTRACKS); + super("showtracks", "Lists the tracks that this group features on", "/%s group showtracks", + Permission.GROUP_SHOWTRACKS, Predicate.alwaysFalse()); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { + public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { plugin.getDatastore().loadAllTracks(success -> { if (!success) { Message.TRACKS_LOAD_ERROR.send(sender); @@ -29,9 +31,4 @@ public class GroupShowTracks extends GroupSubCommand { plugin.getTrackManager().getApplicableTracks(group.getName()).stream().map(Track::getName).collect(Collectors.toList()))); }); } - - @Override - public boolean isArgLengthInvalid(int argLength) { - return false; - } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupUnSetPermission.java b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupUnSetPermission.java index 3c3f5ea7d..fb54a1e86 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupUnSetPermission.java +++ b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupUnSetPermission.java @@ -1,8 +1,9 @@ package me.lucko.luckperms.commands.group.subcommands; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.Predicate; import me.lucko.luckperms.commands.Sender; -import me.lucko.luckperms.commands.group.GroupSubCommand; +import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.exceptions.ObjectLacksException; @@ -11,14 +12,14 @@ import me.lucko.luckperms.utils.Patterns; import java.util.List; -public class GroupUnSetPermission extends GroupSubCommand { +public class GroupUnSetPermission extends SubCommand { public GroupUnSetPermission() { - super("unset", "Unsets a permission for a group", - "/%s group unset [server] [world]", Permission.GROUP_UNSETPERMISSION); + super("unset", "Unsets a permission for a group", "/%s group unset [server] [world]", + Permission.GROUP_UNSETPERMISSION, Predicate.notinRange(1, 3)); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { + public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { String node = args.get(0); if (node.contains("/") || node.contains("$")) { @@ -58,9 +59,4 @@ public class GroupUnSetPermission extends GroupSubCommand { Message.DOES_NOT_HAVEPERMISSION.send(sender, group.getName()); } } - - @Override - public boolean isArgLengthInvalid(int argLength) { - return argLength != 1 && argLength != 2 && argLength != 3; - } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupUnsetInherit.java b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupUnsetInherit.java index dfb3f86bc..d737123f0 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupUnsetInherit.java +++ b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupUnsetInherit.java @@ -1,8 +1,9 @@ package me.lucko.luckperms.commands.group.subcommands; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.Predicate; import me.lucko.luckperms.commands.Sender; -import me.lucko.luckperms.commands.group.GroupSubCommand; +import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.exceptions.ObjectLacksException; @@ -11,14 +12,15 @@ import me.lucko.luckperms.utils.Patterns; import java.util.List; -public class GroupUnsetInherit extends GroupSubCommand { +public class GroupUnsetInherit extends SubCommand { public GroupUnsetInherit() { super("unsetinherit", "Unsets another group for this group to inherit permissions from", - "/%s group unsetinherit [server] [world]", Permission.GROUP_UNSETINHERIT); + "/%s group unsetinherit [server] [world]", Permission.GROUP_UNSETINHERIT, + Predicate.notinRange(1, 3)); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { + public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { String groupName = args.get(0).toLowerCase(); if (groupName.contains("/") || groupName.contains("$")) { @@ -58,9 +60,4 @@ public class GroupUnsetInherit extends GroupSubCommand { public List onTabComplete(Sender sender, List args, LuckPermsPlugin plugin) { return getGroupTabComplete(args, plugin); } - - @Override - public boolean isArgLengthInvalid(int argLength) { - return argLength != 1 && argLength != 2 && argLength != 3; - } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupUnsetTempInherit.java b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupUnsetTempInherit.java index fef160511..dcf6abdf7 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupUnsetTempInherit.java +++ b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupUnsetTempInherit.java @@ -1,8 +1,9 @@ package me.lucko.luckperms.commands.group.subcommands; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.Predicate; import me.lucko.luckperms.commands.Sender; -import me.lucko.luckperms.commands.group.GroupSubCommand; +import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.exceptions.ObjectLacksException; @@ -11,14 +12,15 @@ import me.lucko.luckperms.utils.Patterns; import java.util.List; -public class GroupUnsetTempInherit extends GroupSubCommand { +public class GroupUnsetTempInherit extends SubCommand { public GroupUnsetTempInherit() { super("unsettempinherit", "Unsets another group for this group to inherit permissions from", - "/%s group unsettempinherit [server] [world]", Permission.GROUP_UNSET_TEMP_INHERIT); + "/%s group unsettempinherit [server] [world]", Permission.GROUP_UNSET_TEMP_INHERIT, + Predicate.notinRange(1, 3)); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { + public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { String groupName = args.get(0).toLowerCase(); if (groupName.contains("/") || groupName.contains("$")) { @@ -58,9 +60,4 @@ public class GroupUnsetTempInherit extends GroupSubCommand { public List onTabComplete(Sender sender, List args, LuckPermsPlugin plugin) { return getGroupTabComplete(args, plugin); } - - @Override - public boolean isArgLengthInvalid(int argLength) { - return argLength != 1 && argLength != 2 && argLength != 3; - } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupUnsetTempPermission.java b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupUnsetTempPermission.java index 1c2af0a4f..12f9420a8 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupUnsetTempPermission.java +++ b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupUnsetTempPermission.java @@ -1,8 +1,9 @@ package me.lucko.luckperms.commands.group.subcommands; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.Predicate; import me.lucko.luckperms.commands.Sender; -import me.lucko.luckperms.commands.group.GroupSubCommand; +import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.exceptions.ObjectLacksException; @@ -11,14 +12,15 @@ import me.lucko.luckperms.utils.Patterns; import java.util.List; -public class GroupUnsetTempPermission extends GroupSubCommand { +public class GroupUnsetTempPermission extends SubCommand { public GroupUnsetTempPermission() { super("unsettemp", "Unsets a temporary permission for a group", - "/%s group unsettemp [server] [world]", Permission.GROUP_UNSET_TEMP_PERMISSION); + "/%s group unsettemp [server] [world]", Permission.GROUP_UNSET_TEMP_PERMISSION, + Predicate.notinRange(1, 3)); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { + public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { String node = args.get(0); if (node.contains("/") || node.contains("$")) { @@ -58,9 +60,4 @@ public class GroupUnsetTempPermission extends GroupSubCommand { Message.DOES_NOT_HAVE_TEMP_PERMISSION.send(sender, group.getName()); } } - - @Override - public boolean isArgLengthInvalid(int argLength) { - return argLength != 1 && argLength != 2 && argLength != 3; - } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/misc/DebugCommand.java b/common/src/main/java/me/lucko/luckperms/commands/misc/DebugCommand.java index 64f3452bc..30fc4fb92 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/misc/DebugCommand.java +++ b/common/src/main/java/me/lucko/luckperms/commands/misc/DebugCommand.java @@ -1,16 +1,14 @@ package me.lucko.luckperms.commands.misc; import me.lucko.luckperms.LuckPermsPlugin; -import me.lucko.luckperms.commands.MainCommand; import me.lucko.luckperms.commands.Sender; -import me.lucko.luckperms.commands.SubCommand; +import me.lucko.luckperms.commands.SingleMainCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; -import java.util.Collections; import java.util.List; -public class DebugCommand extends MainCommand { +public class DebugCommand extends SingleMainCommand { public DebugCommand() { super("Debug", "/%s debug", 0); } @@ -23,17 +21,7 @@ public class DebugCommand extends MainCommand { } @Override - protected List onTabComplete(Sender sender, List args, LuckPermsPlugin plugin) { - return Collections.emptyList(); - } - - @Override - public List getSubCommands() { - return Collections.emptyList(); - } - - @Override - protected boolean canUse(Sender sender) { + protected boolean isAuthorized(Sender sender) { return Permission.DEBUG.isAuthorized(sender); } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/misc/InfoCommand.java b/common/src/main/java/me/lucko/luckperms/commands/misc/InfoCommand.java index 0ce3b722d..d0a355f67 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/misc/InfoCommand.java +++ b/common/src/main/java/me/lucko/luckperms/commands/misc/InfoCommand.java @@ -1,17 +1,15 @@ package me.lucko.luckperms.commands.misc; import me.lucko.luckperms.LuckPermsPlugin; -import me.lucko.luckperms.commands.MainCommand; import me.lucko.luckperms.commands.Sender; -import me.lucko.luckperms.commands.SubCommand; +import me.lucko.luckperms.commands.SingleMainCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.utils.LPConfiguration; -import java.util.Collections; import java.util.List; -public class InfoCommand extends MainCommand { +public class InfoCommand extends SingleMainCommand { public InfoCommand() { super("Info", "/%s info", 0); } @@ -24,17 +22,7 @@ public class InfoCommand extends MainCommand { } @Override - protected List onTabComplete(Sender sender, List args, LuckPermsPlugin plugin) { - return Collections.emptyList(); - } - - @Override - public List getSubCommands() { - return Collections.emptyList(); - } - - @Override - protected boolean canUse(Sender sender) { + protected boolean isAuthorized(Sender sender) { return Permission.INFO.isAuthorized(sender); } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/misc/SyncCommand.java b/common/src/main/java/me/lucko/luckperms/commands/misc/SyncCommand.java index 180bf1470..8f6bb6a73 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/misc/SyncCommand.java +++ b/common/src/main/java/me/lucko/luckperms/commands/misc/SyncCommand.java @@ -1,16 +1,14 @@ package me.lucko.luckperms.commands.misc; import me.lucko.luckperms.LuckPermsPlugin; -import me.lucko.luckperms.commands.MainCommand; import me.lucko.luckperms.commands.Sender; -import me.lucko.luckperms.commands.SubCommand; +import me.lucko.luckperms.commands.SingleMainCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; -import java.util.Collections; import java.util.List; -public class SyncCommand extends MainCommand { +public class SyncCommand extends SingleMainCommand { public SyncCommand() { super("Sync", "/%s sync", 0); } @@ -22,17 +20,7 @@ public class SyncCommand extends MainCommand { } @Override - protected List onTabComplete(Sender sender, List args, LuckPermsPlugin plugin) { - return Collections.emptyList(); - } - - @Override - public List getSubCommands() { - return Collections.emptyList(); - } - - @Override - protected boolean canUse(Sender sender) { + protected boolean isAuthorized(Sender sender) { return Permission.SYNC.isAuthorized(sender); } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/track/CreateTrack.java b/common/src/main/java/me/lucko/luckperms/commands/track/CreateTrack.java index e294899b9..ee31c2ffc 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/track/CreateTrack.java +++ b/common/src/main/java/me/lucko/luckperms/commands/track/CreateTrack.java @@ -1,17 +1,15 @@ package me.lucko.luckperms.commands.track; import me.lucko.luckperms.LuckPermsPlugin; -import me.lucko.luckperms.commands.MainCommand; import me.lucko.luckperms.commands.Sender; -import me.lucko.luckperms.commands.SubCommand; +import me.lucko.luckperms.commands.SingleMainCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.utils.Patterns; -import java.util.Collections; import java.util.List; -public class CreateTrack extends MainCommand { +public class CreateTrack extends SingleMainCommand { public CreateTrack() { super("CreateTrack", "/%s createtrack ", 1); } @@ -52,17 +50,7 @@ public class CreateTrack extends MainCommand { } @Override - protected List onTabComplete(Sender sender, List args, LuckPermsPlugin plugin) { - return Collections.emptyList(); - } - - @Override - public List getSubCommands() { - return Collections.emptyList(); - } - - @Override - protected boolean canUse(Sender sender) { + protected boolean isAuthorized(Sender sender) { return Permission.CREATE_TRACK.isAuthorized(sender); } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/track/DeleteTrack.java b/common/src/main/java/me/lucko/luckperms/commands/track/DeleteTrack.java index 8f16c241e..99c140c30 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/track/DeleteTrack.java +++ b/common/src/main/java/me/lucko/luckperms/commands/track/DeleteTrack.java @@ -1,9 +1,8 @@ package me.lucko.luckperms.commands.track; import me.lucko.luckperms.LuckPermsPlugin; -import me.lucko.luckperms.commands.MainCommand; import me.lucko.luckperms.commands.Sender; -import me.lucko.luckperms.commands.SubCommand; +import me.lucko.luckperms.commands.SingleMainCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.tracks.Track; @@ -14,7 +13,7 @@ import java.util.Collections; import java.util.List; import java.util.stream.Collectors; -public class DeleteTrack extends MainCommand { +public class DeleteTrack extends SingleMainCommand { public DeleteTrack() { super("DeleteTrack", "/%s deletetrack ", 1); } @@ -71,12 +70,7 @@ public class DeleteTrack extends MainCommand { } @Override - public List getSubCommands() { - return Collections.emptyList(); - } - - @Override - protected boolean canUse(Sender sender) { + protected boolean isAuthorized(Sender sender) { return Permission.DELETE_TRACK.isAuthorized(sender); } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/track/ListTracks.java b/common/src/main/java/me/lucko/luckperms/commands/track/ListTracks.java index 304e1d63d..1580d75cf 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/track/ListTracks.java +++ b/common/src/main/java/me/lucko/luckperms/commands/track/ListTracks.java @@ -1,18 +1,16 @@ package me.lucko.luckperms.commands.track; import me.lucko.luckperms.LuckPermsPlugin; -import me.lucko.luckperms.commands.MainCommand; import me.lucko.luckperms.commands.Sender; -import me.lucko.luckperms.commands.SubCommand; +import me.lucko.luckperms.commands.SingleMainCommand; import me.lucko.luckperms.commands.Util; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import java.util.ArrayList; -import java.util.Collections; import java.util.List; -public class ListTracks extends MainCommand { +public class ListTracks extends SingleMainCommand { public ListTracks() { super("ListTracks", "/%s listtracks", 0); } @@ -29,17 +27,7 @@ public class ListTracks extends MainCommand { } @Override - protected List onTabComplete(Sender sender, List args, LuckPermsPlugin plugin) { - return Collections.emptyList(); - } - - @Override - public List getSubCommands() { - return Collections.emptyList(); - } - - @Override - protected boolean canUse(Sender sender) { + protected boolean isAuthorized(Sender sender) { return Permission.LIST_TRACKS.isAuthorized(sender); } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/track/TrackMainCommand.java b/common/src/main/java/me/lucko/luckperms/commands/track/TrackMainCommand.java index d68a360af..eb0f7af15 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/track/TrackMainCommand.java +++ b/common/src/main/java/me/lucko/luckperms/commands/track/TrackMainCommand.java @@ -1,101 +1,40 @@ package me.lucko.luckperms.commands.track; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.api.data.Callback; import me.lucko.luckperms.commands.MainCommand; import me.lucko.luckperms.commands.Sender; -import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.tracks.Track; -import me.lucko.luckperms.utils.Patterns; import java.util.ArrayList; import java.util.List; -import java.util.Optional; -import java.util.stream.Collectors; - -public class TrackMainCommand extends MainCommand { - - private final List subCommands = new ArrayList<>(); +public class TrackMainCommand extends MainCommand { public TrackMainCommand() { super("Track", "/%s track ", 2); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, List args, String label) { - if (args.size() < 2) { - sendUsage(sender, label); - return; - } - - Optional o = subCommands.stream().filter(s -> s.getName().equalsIgnoreCase(args.get(1))).limit(1).findAny(); - - if (!o.isPresent()) { - Message.COMMAND_NOT_RECOGNISED.send(sender); - return; - } - - final TrackSubCommand sub = o.get(); - if (!sub.isAuthorized(sender)) { - Message.COMMAND_NO_PERMISSION.send(sender); - return; - } - - List strippedArgs = new ArrayList<>(); - if (args.size() > 2) { - strippedArgs.addAll(args.subList(2, args.size())); - } - - if (sub.isArgLengthInvalid(strippedArgs.size())) { - sub.sendUsage(sender, label); - return; - } - - final String trackName = args.get(0).toLowerCase(); - - if (Patterns.NON_ALPHA_NUMERIC.matcher(trackName).find()) { - Message.TRACK_INVALID_ENTRY.send(sender); - return; - } - - plugin.getDatastore().loadTrack(trackName, success -> { + protected void getTarget(String target, LuckPermsPlugin plugin, Sender sender, Callback onSuccess) { + plugin.getDatastore().loadTrack(target, success -> { if (!success) { Message.TRACK_NOT_FOUND.send(sender); return; } - Track track = plugin.getTrackManager().getTrack(trackName); + Track track = plugin.getTrackManager().getTrack(target); if (track == null) { Message.TRACK_NOT_FOUND.send(sender); return; } - sub.execute(plugin, sender, track, strippedArgs, label); + onSuccess.onComplete(track); }); } @Override - protected List onTabComplete(Sender sender, List args, LuckPermsPlugin plugin) { - final List tracks = new ArrayList<>(plugin.getTrackManager().getTracks().keySet()); - - if (args.size() <= 1) { - if (args.isEmpty() || args.get(0).equalsIgnoreCase("")) { - return tracks; - } - - return tracks.stream().filter(s -> s.toLowerCase().startsWith(args.get(0).toLowerCase())).collect(Collectors.toList()); - } - - return onAbstractTabComplete(sender, args, plugin); + protected List getObjects(LuckPermsPlugin plugin) { + return new ArrayList<>(plugin.getTrackManager().getTracks().keySet()); } - - @Override - public List getSubCommands() { - return subCommands; - } - - public void registerSubCommand(TrackSubCommand subCommand) { - subCommands.add(subCommand); - } - } diff --git a/common/src/main/java/me/lucko/luckperms/commands/track/TrackSubCommand.java b/common/src/main/java/me/lucko/luckperms/commands/track/TrackSubCommand.java deleted file mode 100644 index 13752dbc1..000000000 --- a/common/src/main/java/me/lucko/luckperms/commands/track/TrackSubCommand.java +++ /dev/null @@ -1,30 +0,0 @@ -package me.lucko.luckperms.commands.track; - -import me.lucko.luckperms.LuckPermsPlugin; -import me.lucko.luckperms.commands.Sender; -import me.lucko.luckperms.commands.SubCommand; -import me.lucko.luckperms.constants.Message; -import me.lucko.luckperms.constants.Permission; -import me.lucko.luckperms.tracks.Track; - -import java.util.List; - -public abstract class TrackSubCommand extends SubCommand { - public TrackSubCommand(String name, String description, String usage, Permission permission) { - super(name, description, usage, permission); - } - - protected abstract void execute(LuckPermsPlugin plugin, Sender sender, Track track, List args, String label); - - protected void saveTrack(Track track, Sender sender, LuckPermsPlugin plugin) { - plugin.getDatastore().saveTrack(track, success -> { - if (success) { - Message.TRACK_SAVE_SUCCESS.send(sender); - } else { - Message.TRACK_SAVE_ERROR.send(sender); - } - - plugin.runUpdateTask(); - }); - } -} diff --git a/common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackAppend.java b/common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackAppend.java index ecd5bfcb8..b04011fea 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackAppend.java +++ b/common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackAppend.java @@ -1,9 +1,10 @@ package me.lucko.luckperms.commands.track.subcommands; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.Predicate; import me.lucko.luckperms.commands.Sender; +import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.commands.Util; -import me.lucko.luckperms.commands.track.TrackSubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.exceptions.ObjectAlreadyHasException; @@ -12,13 +13,14 @@ import me.lucko.luckperms.tracks.Track; import java.util.List; -public class TrackAppend extends TrackSubCommand { +public class TrackAppend extends SubCommand { public TrackAppend() { - super("append", "Appends a group onto the end of the track", "/%s track append ", Permission.TRACK_APPEND); + super("append", "Appends a group onto the end of the track", "/%s track append ", + Permission.TRACK_APPEND, Predicate.notOneOf(new Integer[]{1})); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, Track track, List args, String label) { + public void execute(LuckPermsPlugin plugin, Sender sender, Track track, List args, String label) { String groupName = args.get(0).toLowerCase(); plugin.getDatastore().loadGroup(groupName, success -> { @@ -47,9 +49,4 @@ public class TrackAppend extends TrackSubCommand { public List onTabComplete(Sender sender, List args, LuckPermsPlugin plugin) { return getGroupTabComplete(args, plugin); } - - @Override - public boolean isArgLengthInvalid(int argLength) { - return argLength != 1; - } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackClear.java b/common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackClear.java index 09ad610b1..3eb6f3e35 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackClear.java +++ b/common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackClear.java @@ -1,28 +1,25 @@ package me.lucko.luckperms.commands.track.subcommands; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.Predicate; import me.lucko.luckperms.commands.Sender; -import me.lucko.luckperms.commands.track.TrackSubCommand; +import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.tracks.Track; import java.util.List; -public class TrackClear extends TrackSubCommand { +public class TrackClear extends SubCommand { public TrackClear() { - super("clear", "Clears the groups on the track", "/%s track clear", Permission.TRACK_CLEAR); + super("clear", "Clears the groups on the track", "/%s track clear", Permission.TRACK_CLEAR, + Predicate.alwaysFalse()); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, Track track, List args, String label) { + public void execute(LuckPermsPlugin plugin, Sender sender, Track track, List args, String label) { track.clearGroups(); Message.TRACK_CLEAR.send(sender, track.getName()); saveTrack(track, sender, plugin); } - - @Override - public boolean isArgLengthInvalid(int argLength) { - return false; - } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackInfo.java b/common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackInfo.java index 576df3de0..a2ed90df0 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackInfo.java +++ b/common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackInfo.java @@ -1,27 +1,24 @@ package me.lucko.luckperms.commands.track.subcommands; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.Predicate; import me.lucko.luckperms.commands.Sender; +import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.commands.Util; -import me.lucko.luckperms.commands.track.TrackSubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.tracks.Track; import java.util.List; -public class TrackInfo extends TrackSubCommand { +public class TrackInfo extends SubCommand { public TrackInfo() { - super("info", "Gives info about the track", "/%s track info", Permission.TRACK_INFO); + super("info", "Gives info about the track", "/%s track info", Permission.TRACK_INFO, + Predicate.alwaysFalse()); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, Track track, List args, String label) { + public void execute(LuckPermsPlugin plugin, Sender sender, Track track, List args, String label) { Message.TRACK_INFO.send(sender, track.getName(), Util.listToArrowSep(track.getGroups())); } - - @Override - public boolean isArgLengthInvalid(int argLength) { - return false; - } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackInsert.java b/common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackInsert.java index 7523df6df..873e28b00 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackInsert.java +++ b/common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackInsert.java @@ -1,9 +1,10 @@ package me.lucko.luckperms.commands.track.subcommands; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.Predicate; import me.lucko.luckperms.commands.Sender; +import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.commands.Util; -import me.lucko.luckperms.commands.track.TrackSubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.exceptions.ObjectAlreadyHasException; @@ -12,14 +13,14 @@ import me.lucko.luckperms.tracks.Track; import java.util.List; -public class TrackInsert extends TrackSubCommand { +public class TrackInsert extends SubCommand { public TrackInsert() { super("insert", "Inserts a group at a given position along the track", - "/%s track insert ", Permission.TRACK_INSERT); + "/%s track insert ", Permission.TRACK_INSERT, Predicate.notOneOf(new Integer[]{2})); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, Track track, List args, String label) { + public void execute(LuckPermsPlugin plugin, Sender sender, Track track, List args, String label) { String groupName = args.get(0).toLowerCase(); int pos; try { @@ -57,9 +58,4 @@ public class TrackInsert extends TrackSubCommand { public List onTabComplete(Sender sender, List args, LuckPermsPlugin plugin) { return getGroupTabComplete(args, plugin); } - - @Override - public boolean isArgLengthInvalid(int argLength) { - return argLength != 2; - } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackRemove.java b/common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackRemove.java index abd168e39..18934b36f 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackRemove.java +++ b/common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackRemove.java @@ -1,8 +1,9 @@ package me.lucko.luckperms.commands.track.subcommands; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.Predicate; import me.lucko.luckperms.commands.Sender; -import me.lucko.luckperms.commands.track.TrackSubCommand; +import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.exceptions.ObjectLacksException; @@ -10,13 +11,14 @@ import me.lucko.luckperms.tracks.Track; import java.util.List; -public class TrackRemove extends TrackSubCommand { +public class TrackRemove extends SubCommand { public TrackRemove() { - super("remove", "Removes a group from the track", "/%s track remove ", Permission.TRACK_REMOVE); + super("remove", "Removes a group from the track", "/%s track remove ", Permission.TRACK_REMOVE, + Predicate.notOneOf(new Integer[]{1})); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, Track track, List args, String label) { + public void execute(LuckPermsPlugin plugin, Sender sender, Track track, List args, String label) { String groupName = args.get(0).toLowerCase(); try { track.removeGroup(groupName); @@ -31,9 +33,4 @@ public class TrackRemove extends TrackSubCommand { public List onTabComplete(Sender sender, List args, LuckPermsPlugin plugin) { return getGroupTabComplete(args, plugin); } - - @Override - public boolean isArgLengthInvalid(int argLength) { - return argLength != 1; - } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/user/UserMainCommand.java b/common/src/main/java/me/lucko/luckperms/commands/user/UserMainCommand.java index 7d8aa4f5f..edd523861 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/user/UserMainCommand.java +++ b/common/src/main/java/me/lucko/luckperms/commands/user/UserMainCommand.java @@ -1,104 +1,53 @@ package me.lucko.luckperms.commands.user; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.api.data.Callback; import me.lucko.luckperms.commands.MainCommand; import me.lucko.luckperms.commands.Sender; -import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.commands.Util; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.users.User; import me.lucko.luckperms.utils.Patterns; -import java.util.ArrayList; import java.util.List; -import java.util.Optional; import java.util.UUID; -import java.util.stream.Collectors; - -public class UserMainCommand extends MainCommand { - - private final List subCommands = new ArrayList<>(); +public class UserMainCommand extends MainCommand { public UserMainCommand() { super("User", "/%s user ", 2); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, List args, String label) { - if (args.size() < 2) { - sendUsage(sender, label); - return; - } - - Optional o = subCommands.stream().filter(s -> s.getName().equalsIgnoreCase(args.get(1))).limit(1).findAny(); - - if (!o.isPresent()) { - Message.COMMAND_NOT_RECOGNISED.send(sender); - return; - } - - final UserSubCommand sub = o.get(); - if (!sub.isAuthorized(sender)) { - Message.COMMAND_NO_PERMISSION.send(sender); - return; - } - - // The arguments to be passed onto the sub command - List strippedArgs = new ArrayList<>(); - if (args.size() > 2) { - strippedArgs.addAll(args.subList(2, args.size())); - } - - if (sub.isArgLengthInvalid(strippedArgs.size())) { - sub.sendUsage(sender, label); - return; - } - - final String user = args.get(0); - - if (Patterns.NON_USERNAME.matcher(user).find()) { - Message.USER_INVALID_ENTRY.send(sender, user); - return; - } - - UUID u = Util.parseUuid(user); + protected void getTarget(String target, LuckPermsPlugin plugin, Sender sender, Callback onSuccess) { + UUID u = Util.parseUuid(target); if (u != null) { - runSub(plugin, sender, u, sub, strippedArgs, label); + runSub(plugin, sender, u, onSuccess); return; } - if (user.length() <= 16) { + if (target.length() <= 16) { + if (Patterns.NON_USERNAME.matcher(target).find()) { + Message.USER_INVALID_ENTRY.send(sender, target); + return; + } + Message.USER_ATTEMPTING_LOOKUP.send(sender); - plugin.getDatastore().getUUID(user, uuid -> { + plugin.getDatastore().getUUID(target, uuid -> { if (uuid == null) { Message.USER_NOT_FOUND.send(sender); return; } - runSub(plugin, sender, uuid, sub, strippedArgs, label); + + runSub(plugin, sender, uuid, onSuccess); }); return; } - Message.USER_INVALID_ENTRY.send(sender, user); + Message.USER_INVALID_ENTRY.send(sender, target); } - @Override - protected List onTabComplete(Sender sender, List args, LuckPermsPlugin plugin) { - final List onlinePlayers = plugin.getPlayerList(); - - if (args.size() <= 1) { - if (args.isEmpty() || args.get(0).equalsIgnoreCase("")) { - return onlinePlayers; - } - - return onlinePlayers.stream().filter(s -> s.toLowerCase().startsWith(args.get(0).toLowerCase())).collect(Collectors.toList()); - } - - return onAbstractTabComplete(sender, args, plugin); - } - - private void runSub(LuckPermsPlugin plugin, Sender sender, UUID uuid, UserSubCommand command, List strippedArgs, String label) { + private void runSub(LuckPermsPlugin plugin, Sender sender, UUID uuid, Callback onSuccess) { plugin.getDatastore().loadUser(uuid, success -> { if (!success) { Message.USER_NOT_FOUND.send(sender); @@ -108,19 +57,16 @@ public class UserMainCommand extends MainCommand { User user = plugin.getUserManager().getUser(uuid); if (user == null) { Message.USER_NOT_FOUND.send(sender); + return; } - command.execute(plugin, sender, user, strippedArgs, label); + onSuccess.onComplete(user); plugin.getUserManager().cleanupUser(user); }); } @Override - public List getSubCommands() { - return subCommands; - } - - public void registerSubCommand(UserSubCommand subCommand) { - subCommands.add(subCommand); + protected List getObjects(LuckPermsPlugin plugin) { + return plugin.getPlayerList(); } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/user/UserSubCommand.java b/common/src/main/java/me/lucko/luckperms/commands/user/UserSubCommand.java deleted file mode 100644 index 8d9fca7e7..000000000 --- a/common/src/main/java/me/lucko/luckperms/commands/user/UserSubCommand.java +++ /dev/null @@ -1,30 +0,0 @@ -package me.lucko.luckperms.commands.user; - -import me.lucko.luckperms.LuckPermsPlugin; -import me.lucko.luckperms.commands.Sender; -import me.lucko.luckperms.commands.SubCommand; -import me.lucko.luckperms.constants.Message; -import me.lucko.luckperms.constants.Permission; -import me.lucko.luckperms.users.User; - -import java.util.List; - -public abstract class UserSubCommand extends SubCommand { - protected UserSubCommand(String name, String description, String usage, Permission permission) { - super(name, description, usage, permission); - } - - protected abstract void execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label); - - protected void saveUser(User user, Sender sender, LuckPermsPlugin plugin) { - user.refreshPermissions(); - - plugin.getDatastore().saveUser(user, success -> { - if (success) { - Message.USER_SAVE_SUCCESS.send(sender); - } else { - Message.USER_SAVE_ERROR.send(sender); - } - }); - } -} diff --git a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserAddGroup.java b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserAddGroup.java index 22e4486cf..0870a1711 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserAddGroup.java +++ b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserAddGroup.java @@ -1,8 +1,9 @@ package me.lucko.luckperms.commands.user.subcommands; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.Predicate; import me.lucko.luckperms.commands.Sender; -import me.lucko.luckperms.commands.user.UserSubCommand; +import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.exceptions.ObjectAlreadyHasException; @@ -12,13 +13,14 @@ import me.lucko.luckperms.utils.Patterns; import java.util.List; -public class UserAddGroup extends UserSubCommand { +public class UserAddGroup extends SubCommand { public UserAddGroup() { - super("addgroup", "Adds the user to a group", "/%s user addgroup [server] [world]", Permission.USER_ADDGROUP); + super("addgroup", "Adds the user to a group", "/%s user addgroup [server] [world]", + Permission.USER_ADDGROUP, Predicate.notinRange(1, 3)); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { + public void execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { String groupName = args.get(0).toLowerCase(); if (groupName.contains("/") || groupName.contains("$")) { @@ -70,9 +72,4 @@ public class UserAddGroup extends UserSubCommand { public List onTabComplete(Sender sender, List args, LuckPermsPlugin plugin) { return getGroupTabComplete(args, plugin); } - - @Override - public boolean isArgLengthInvalid(int argLength) { - return (argLength != 1 && argLength != 2 && argLength != 3); - } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserAddTempGroup.java b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserAddTempGroup.java index 0571ff55a..14623af11 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserAddTempGroup.java +++ b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserAddTempGroup.java @@ -1,8 +1,9 @@ package me.lucko.luckperms.commands.user.subcommands; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.Predicate; import me.lucko.luckperms.commands.Sender; -import me.lucko.luckperms.commands.user.UserSubCommand; +import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.exceptions.ObjectAlreadyHasException; @@ -13,14 +14,15 @@ import me.lucko.luckperms.utils.Patterns; import java.util.List; -public class UserAddTempGroup extends UserSubCommand { +public class UserAddTempGroup extends SubCommand { public UserAddTempGroup() { super("addtempgroup", "Adds the user to a group temporarily", - "/%s user addtempgroup [server] [world]", Permission.USER_ADDTEMPGROUP); + "/%s user addtempgroup [server] [world]", Permission.USER_ADDTEMPGROUP, + Predicate.notinRange(2, 4)); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { + public void execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { String groupName = args.get(0).toLowerCase(); if (groupName.contains("/") || groupName.contains("$")) { @@ -87,9 +89,4 @@ public class UserAddTempGroup extends UserSubCommand { public List onTabComplete(Sender sender, List args, LuckPermsPlugin plugin) { return getGroupTabComplete(args, plugin); } - - @Override - public boolean isArgLengthInvalid(int argLength) { - return (argLength != 2 && argLength != 3 && argLength != 4); - } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserClear.java b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserClear.java index 5e949ad0e..73a5db3b5 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserClear.java +++ b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserClear.java @@ -1,30 +1,27 @@ package me.lucko.luckperms.commands.user.subcommands; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.Predicate; import me.lucko.luckperms.commands.Sender; -import me.lucko.luckperms.commands.user.UserSubCommand; +import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.users.User; import java.util.List; -public class UserClear extends UserSubCommand { +public class UserClear extends SubCommand { public UserClear() { - super("clear", "Clears a users permissions and groups", "/%s user clear", Permission.USER_CLEAR); + super("clear", "Clears a users permissions and groups", "/%s user clear", Permission.USER_CLEAR, + Predicate.alwaysFalse()); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { + public void execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { user.clearNodes(); plugin.getUserManager().giveDefaults(user); Message.CLEAR_SUCCESS.send(sender, user.getName()); saveUser(user, sender, plugin); } - - @Override - public boolean isArgLengthInvalid(int argLength) { - return false; - } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserDemote.java b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserDemote.java index eb97458d8..264d13239 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserDemote.java +++ b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserDemote.java @@ -1,9 +1,10 @@ package me.lucko.luckperms.commands.user.subcommands; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.Predicate; import me.lucko.luckperms.commands.Sender; +import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.commands.Util; -import me.lucko.luckperms.commands.user.UserSubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.exceptions.ObjectAlreadyHasException; @@ -14,13 +15,14 @@ import me.lucko.luckperms.users.User; import java.util.List; -public class UserDemote extends UserSubCommand { +public class UserDemote extends SubCommand { public UserDemote() { - super("demote", "Demotes a user along a track", "/%s user demote ", Permission.USER_DEMOTE); + super("demote", "Demotes a user along a track", "/%s user demote ", Permission.USER_DEMOTE, + Predicate.notOneOf(new Integer[]{1})); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { + public void execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { final String trackName = args.get(0).toLowerCase(); plugin.getDatastore().loadTrack(trackName, success -> { @@ -85,9 +87,4 @@ public class UserDemote extends UserSubCommand { public List onTabComplete(Sender sender, List args, LuckPermsPlugin plugin) { return getTrackTabComplete(args, plugin); } - - @Override - public boolean isArgLengthInvalid(int argLength) { - return argLength != 1; - } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserGetUUID.java b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserGetUUID.java index 63da5333b..04369d31c 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserGetUUID.java +++ b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserGetUUID.java @@ -1,26 +1,23 @@ package me.lucko.luckperms.commands.user.subcommands; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.Predicate; import me.lucko.luckperms.commands.Sender; -import me.lucko.luckperms.commands.user.UserSubCommand; +import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.users.User; import java.util.List; -public class UserGetUUID extends UserSubCommand { +public class UserGetUUID extends SubCommand { public UserGetUUID() { - super("getuuid", "Get the UUID of a user", "/%s user getuuid", Permission.USER_GETUUID); + super("getuuid", "Get the UUID of a user", "/%s user getuuid", Permission.USER_GETUUID, + Predicate.alwaysFalse()); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { + public void execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { Message.USER_GETUUID.send(sender, user.getName(), user.getUuid().toString()); } - - @Override - public boolean isArgLengthInvalid(int argLength) { - return false; - } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserHasPerm.java b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserHasPerm.java index a5ab03dc8..6ddb62029 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserHasPerm.java +++ b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserHasPerm.java @@ -1,9 +1,10 @@ package me.lucko.luckperms.commands.user.subcommands; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.Predicate; import me.lucko.luckperms.commands.Sender; +import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.commands.Util; -import me.lucko.luckperms.commands.user.UserSubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.users.User; @@ -11,14 +12,15 @@ import me.lucko.luckperms.utils.Patterns; import java.util.List; -public class UserHasPerm extends UserSubCommand { +public class UserHasPerm extends SubCommand { public UserHasPerm() { super("haspermission", "Checks to see if a user has a certain permission node", - "/%s user haspermission [server] [world]", Permission.USER_HASPERMISSION); + "/%s user haspermission [server] [world]", Permission.USER_HASPERMISSION, + Predicate.notinRange(1, 3)); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { + public void execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { if (args.size() >= 2) { if (Patterns.NON_ALPHA_NUMERIC.matcher(args.get(1)).find()) { Message.SERVER_INVALID_ENTRY.send(sender); @@ -35,9 +37,4 @@ public class UserHasPerm extends UserSubCommand { Util.sendBoolean(sender, args.get(0), user.hasPermission(args.get(0), true, "global")); } } - - @Override - public boolean isArgLengthInvalid(int argLength) { - return argLength != 1 && argLength != 2 && argLength != 3; - } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserInfo.java b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserInfo.java index 0f6c232ff..59663d289 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserInfo.java +++ b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserInfo.java @@ -1,30 +1,26 @@ package me.lucko.luckperms.commands.user.subcommands; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.Predicate; import me.lucko.luckperms.commands.Sender; +import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.commands.Util; -import me.lucko.luckperms.commands.user.UserSubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.users.User; import java.util.List; -public class UserInfo extends UserSubCommand { +public class UserInfo extends SubCommand { public UserInfo() { - super("info", "Gives info about the user", "/%s user info", Permission.USER_INFO); + super("info", "Gives info about the user", "/%s user info", Permission.USER_INFO, Predicate.alwaysFalse()); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { + public void execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { Message.USER_INFO.send(sender, user.getName(), user.getUuid(), plugin.getPlayerStatus(user.getUuid()), Util.listToCommaSep(user.getGroupNames()), user.getPrimaryGroup(), user.getPermanentNodes().keySet().size(), user.getTemporaryNodes().keySet().size(), label, user.getName() ); } - - @Override - public boolean isArgLengthInvalid(int argLength) { - return false; - } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserInheritsPerm.java b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserInheritsPerm.java index 242908929..c1c813c49 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserInheritsPerm.java +++ b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserInheritsPerm.java @@ -1,9 +1,10 @@ package me.lucko.luckperms.commands.user.subcommands; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.Predicate; import me.lucko.luckperms.commands.Sender; +import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.commands.Util; -import me.lucko.luckperms.commands.user.UserSubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.users.User; @@ -11,14 +12,15 @@ import me.lucko.luckperms.utils.Patterns; import java.util.List; -public class UserInheritsPerm extends UserSubCommand { +public class UserInheritsPerm extends SubCommand { public UserInheritsPerm() { super("inheritspermission", "Checks to see if a user inherits a certain permission node", - "/%s user inheritspermission [server] [world]", Permission.USER_INHERITSPERMISSION); + "/%s user inheritspermission [server] [world]", Permission.USER_INHERITSPERMISSION, + Predicate.notinRange(1, 3)); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { + public void execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { if (args.size() >= 2) { if (Patterns.NON_ALPHA_NUMERIC.matcher(args.get(1)).find()) { Message.SERVER_INVALID_ENTRY.send(sender); @@ -35,9 +37,4 @@ public class UserInheritsPerm extends UserSubCommand { Util.sendBoolean(sender, args.get(0), user.inheritsPermission(args.get(0), true)); } } - - @Override - public boolean isArgLengthInvalid(int argLength) { - return argLength != 1 && argLength != 2 && argLength != 3; - } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserListNodes.java b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserListNodes.java index 6b4147860..ecda79a69 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserListNodes.java +++ b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserListNodes.java @@ -1,28 +1,25 @@ package me.lucko.luckperms.commands.user.subcommands; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.Predicate; import me.lucko.luckperms.commands.Sender; +import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.commands.Util; -import me.lucko.luckperms.commands.user.UserSubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.users.User; import java.util.List; -public class UserListNodes extends UserSubCommand { +public class UserListNodes extends SubCommand { public UserListNodes() { - super("listnodes", "Lists the permission nodes the user has", "/%s user listnodes", Permission.USER_LISTNODES); + super("listnodes", "Lists the permission nodes the user has", "/%s user listnodes", + Permission.USER_LISTNODES, Predicate.alwaysFalse()); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { + public void execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { Message.LISTNODES.send(sender, user.getName(), Util.permNodesToString(user.getPermanentNodes())); Message.LISTNODES_TEMP.send(sender, user.getName(), Util.tempNodesToString(user.getTemporaryNodes())); } - - @Override - public boolean isArgLengthInvalid(int argLength) { - return false; - } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserPromote.java b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserPromote.java index b8319cb91..daff67bed 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserPromote.java +++ b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserPromote.java @@ -1,9 +1,10 @@ package me.lucko.luckperms.commands.user.subcommands; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.Predicate; import me.lucko.luckperms.commands.Sender; +import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.commands.Util; -import me.lucko.luckperms.commands.user.UserSubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.exceptions.ObjectAlreadyHasException; @@ -14,13 +15,14 @@ import me.lucko.luckperms.users.User; import java.util.List; -public class UserPromote extends UserSubCommand { +public class UserPromote extends SubCommand { public UserPromote() { - super("promote", "Promotes the user along a track", "/%s user promote ", Permission.USER_PROMOTE); + super("promote", "Promotes the user along a track", "/%s user promote ", Permission.USER_PROMOTE, + Predicate.notOneOf(new Integer[]{1})); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { + public void execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { final String trackName = args.get(0).toLowerCase(); plugin.getDatastore().loadTrack(trackName, success -> { @@ -85,9 +87,4 @@ public class UserPromote extends UserSubCommand { public List onTabComplete(Sender sender, List args, LuckPermsPlugin plugin) { return getTrackTabComplete(args, plugin); } - - @Override - public boolean isArgLengthInvalid(int argLength) { - return argLength != 1; - } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserRemoveGroup.java b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserRemoveGroup.java index 7e9f952a7..9550a0908 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserRemoveGroup.java +++ b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserRemoveGroup.java @@ -1,8 +1,9 @@ package me.lucko.luckperms.commands.user.subcommands; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.Predicate; import me.lucko.luckperms.commands.Sender; -import me.lucko.luckperms.commands.user.UserSubCommand; +import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.exceptions.ObjectLacksException; @@ -11,13 +12,14 @@ import me.lucko.luckperms.utils.Patterns; import java.util.List; -public class UserRemoveGroup extends UserSubCommand { +public class UserRemoveGroup extends SubCommand { public UserRemoveGroup() { - super("removegroup", "Removes a user from a group", "/%s user removegroup [server] [world]", Permission.USER_REMOVEGROUP); + super("removegroup", "Removes a user from a group", "/%s user removegroup [server] [world]", + Permission.USER_REMOVEGROUP, Predicate.notinRange(1, 3)); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { + public void execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { String groupName = args.get(0).toLowerCase(); if (groupName.contains("/") || groupName.contains("$")) { @@ -63,9 +65,4 @@ public class UserRemoveGroup extends UserSubCommand { public List onTabComplete(Sender sender, List args, LuckPermsPlugin plugin) { return getGroupTabComplete(args, plugin); } - - @Override - public boolean isArgLengthInvalid(int argLength) { - return (argLength != 1 && argLength != 2 && argLength != 3); - } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserRemoveTempGroup.java b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserRemoveTempGroup.java index 129dd93a5..8a9bf2bb9 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserRemoveTempGroup.java +++ b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserRemoveTempGroup.java @@ -1,8 +1,9 @@ package me.lucko.luckperms.commands.user.subcommands; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.Predicate; import me.lucko.luckperms.commands.Sender; -import me.lucko.luckperms.commands.user.UserSubCommand; +import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.exceptions.ObjectLacksException; @@ -11,14 +12,15 @@ import me.lucko.luckperms.utils.Patterns; import java.util.List; -public class UserRemoveTempGroup extends UserSubCommand { +public class UserRemoveTempGroup extends SubCommand { public UserRemoveTempGroup() { super("removetempgroup", "Removes a user from a temporary group", - "/%s user removetempgroup [server] [world]", Permission.USER_REMOVETEMPGROUP); + "/%s user removetempgroup [server] [world]", Permission.USER_REMOVETEMPGROUP, + Predicate.notinRange(1, 3)); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { + public void execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { String groupName = args.get(0).toLowerCase(); if (groupName.contains("/") || groupName.contains("$")) { @@ -58,9 +60,4 @@ public class UserRemoveTempGroup extends UserSubCommand { public List onTabComplete(Sender sender, List args, LuckPermsPlugin plugin) { return getGroupTabComplete(args, plugin); } - - @Override - public boolean isArgLengthInvalid(int argLength) { - return (argLength != 1 && argLength != 2 && argLength != 3); - } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserSetPermission.java b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserSetPermission.java index a73952042..800e3baa3 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserSetPermission.java +++ b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserSetPermission.java @@ -1,8 +1,9 @@ package me.lucko.luckperms.commands.user.subcommands; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.Predicate; import me.lucko.luckperms.commands.Sender; -import me.lucko.luckperms.commands.user.UserSubCommand; +import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.exceptions.ObjectAlreadyHasException; @@ -11,14 +12,15 @@ import me.lucko.luckperms.utils.Patterns; import java.util.List; -public class UserSetPermission extends UserSubCommand { +public class UserSetPermission extends SubCommand { public UserSetPermission() { super("set", "Sets a permission for a user", - "/%s user set [server] [world]", Permission.USER_SETPERMISSION); + "/%s user set [server] [world]", Permission.USER_SETPERMISSION, + Predicate.notinRange(2, 4)); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { + public void execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { String node = args.get(0); String bool = args.get(1).toLowerCase(); @@ -71,9 +73,4 @@ public class UserSetPermission extends UserSubCommand { public List onTabComplete(Sender sender, List args, LuckPermsPlugin plugin) { return getBoolTabComplete(args); } - - @Override - public boolean isArgLengthInvalid(int argLength) { - return argLength != 2 && argLength != 3 && argLength != 4; - } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserSetPrimaryGroup.java b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserSetPrimaryGroup.java index 50487ffd5..276f95011 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserSetPrimaryGroup.java +++ b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserSetPrimaryGroup.java @@ -1,8 +1,9 @@ package me.lucko.luckperms.commands.user.subcommands; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.Predicate; import me.lucko.luckperms.commands.Sender; -import me.lucko.luckperms.commands.user.UserSubCommand; +import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.groups.Group; @@ -10,14 +11,14 @@ import me.lucko.luckperms.users.User; import java.util.List; -public class UserSetPrimaryGroup extends UserSubCommand { +public class UserSetPrimaryGroup extends SubCommand { public UserSetPrimaryGroup() { super("setprimarygroup", "Sets a users primary group", - "/%s user setprimarygroup ", Permission.USER_SETPRIMARYGROUP); + "/%s user setprimarygroup ", Permission.USER_SETPRIMARYGROUP, Predicate.notOneOf(new Integer[]{1})); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { + public void execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { Group group = plugin.getGroupManager().getGroup(args.get(0).toLowerCase()); if (group == null) { Message.GROUP_DOES_NOT_EXIST.send(sender); @@ -44,9 +45,4 @@ public class UserSetPrimaryGroup extends UserSubCommand { public List onTabComplete(Sender sender, List args, LuckPermsPlugin plugin) { return getGroupTabComplete(args, plugin); } - - @Override - public boolean isArgLengthInvalid(int argLength) { - return argLength != 1; - } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserSetTempPermission.java b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserSetTempPermission.java index c3dc644fb..3824cb8de 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserSetTempPermission.java +++ b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserSetTempPermission.java @@ -1,8 +1,9 @@ package me.lucko.luckperms.commands.user.subcommands; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.Predicate; import me.lucko.luckperms.commands.Sender; -import me.lucko.luckperms.commands.user.UserSubCommand; +import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.exceptions.ObjectAlreadyHasException; @@ -12,14 +13,15 @@ import me.lucko.luckperms.utils.Patterns; import java.util.List; -public class UserSetTempPermission extends UserSubCommand { +public class UserSetTempPermission extends SubCommand { public UserSetTempPermission() { super("settemp", "Sets a temporary permission for a user", - "/%s user settemp [server] [world]", Permission.USER_SET_TEMP_PERMISSION); + "/%s user settemp [server] [world]", + Permission.USER_SET_TEMP_PERMISSION, Predicate.notinRange(3, 5)); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { + public void execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { String node = args.get(0); String bool = args.get(1).toLowerCase(); @@ -85,9 +87,4 @@ public class UserSetTempPermission extends UserSubCommand { public List onTabComplete(Sender sender, List args, LuckPermsPlugin plugin) { return getBoolTabComplete(args); } - - @Override - public boolean isArgLengthInvalid(int argLength) { - return argLength != 3 && argLength != 4 && argLength != 5; - } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserShowPos.java b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserShowPos.java index 0404bcbaa..165bc10dc 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserShowPos.java +++ b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserShowPos.java @@ -1,9 +1,10 @@ package me.lucko.luckperms.commands.user.subcommands; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.Predicate; import me.lucko.luckperms.commands.Sender; +import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.commands.Util; -import me.lucko.luckperms.commands.user.UserSubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.tracks.Track; @@ -11,13 +12,14 @@ import me.lucko.luckperms.users.User; import java.util.List; -public class UserShowPos extends UserSubCommand { +public class UserShowPos extends SubCommand { public UserShowPos() { - super("showpos", "Shows a users position on a track", "/%s user showpos ", Permission.USER_SHOWPOS); + super("showpos", "Shows a users position on a track", "/%s user showpos ", Permission.USER_SHOWPOS, + Predicate.notOneOf(new Integer[]{1})); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { + public void execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { final String trackName = args.get(0).toLowerCase(); plugin.getDatastore().loadTrack(trackName, success -> { @@ -49,9 +51,4 @@ public class UserShowPos extends UserSubCommand { public List onTabComplete(Sender sender, List args, LuckPermsPlugin plugin) { return getTrackTabComplete(args, plugin); } - - @Override - public boolean isArgLengthInvalid(int argLength) { - return argLength != 1; - } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserShowTracks.java b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserShowTracks.java index e35b3e492..a4be483a7 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserShowTracks.java +++ b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserShowTracks.java @@ -1,9 +1,10 @@ package me.lucko.luckperms.commands.user.subcommands; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.Predicate; import me.lucko.luckperms.commands.Sender; +import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.commands.Util; -import me.lucko.luckperms.commands.user.UserSubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.tracks.Track; @@ -12,14 +13,14 @@ import me.lucko.luckperms.users.User; import java.util.List; import java.util.stream.Collectors; -public class UserShowTracks extends UserSubCommand { +public class UserShowTracks extends SubCommand { public UserShowTracks() { super("showtracks", "Lists the tracks that this user's primary group features on", "/%s user showtracks", - Permission.USER_SHOWTRACKS); + Permission.USER_SHOWTRACKS, Predicate.alwaysFalse()); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { + public void execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { plugin.getDatastore().loadAllTracks(success -> { if (!success) { Message.TRACKS_LOAD_ERROR.send(sender); @@ -31,9 +32,4 @@ public class UserShowTracks extends UserSubCommand { plugin.getTrackManager().getApplicableTracks(user.getPrimaryGroup()).stream().map(Track::getName).collect(Collectors.toList()))); }); } - - @Override - public boolean isArgLengthInvalid(int argLength) { - return false; - } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserUnSetPermission.java b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserUnSetPermission.java index a775cd5a5..0bb8e7604 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserUnSetPermission.java +++ b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserUnSetPermission.java @@ -1,8 +1,9 @@ package me.lucko.luckperms.commands.user.subcommands; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.Predicate; import me.lucko.luckperms.commands.Sender; -import me.lucko.luckperms.commands.user.UserSubCommand; +import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.exceptions.ObjectLacksException; @@ -11,14 +12,14 @@ import me.lucko.luckperms.utils.Patterns; import java.util.List; -public class UserUnSetPermission extends UserSubCommand { +public class UserUnSetPermission extends SubCommand { public UserUnSetPermission() { super("unset", "Unsets a permission for a user", - "/%s user unset [server] [world]", Permission.USER_UNSETPERMISSION); + "/%s user unset [server] [world]", Permission.USER_UNSETPERMISSION, Predicate.notinRange(1, 3)); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { + public void execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { String node = args.get(0); if (node.contains("/") || node.contains("$")) { @@ -58,9 +59,4 @@ public class UserUnSetPermission extends UserSubCommand { Message.DOES_NOT_HAVEPERMISSION.send(sender, user.getName()); } } - - @Override - public boolean isArgLengthInvalid(int argLength) { - return argLength != 1 && argLength != 2 && argLength != 3; - } } diff --git a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserUnsetTempPermission.java b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserUnsetTempPermission.java index c119dcf6d..a015dadfa 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserUnsetTempPermission.java +++ b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserUnsetTempPermission.java @@ -1,8 +1,9 @@ package me.lucko.luckperms.commands.user.subcommands; import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.Predicate; import me.lucko.luckperms.commands.Sender; -import me.lucko.luckperms.commands.user.UserSubCommand; +import me.lucko.luckperms.commands.SubCommand; import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Permission; import me.lucko.luckperms.exceptions.ObjectLacksException; @@ -11,14 +12,15 @@ import me.lucko.luckperms.utils.Patterns; import java.util.List; -public class UserUnsetTempPermission extends UserSubCommand { +public class UserUnsetTempPermission extends SubCommand { public UserUnsetTempPermission() { super("unsettemp", "Unsets a temporary permission for a user", - "/%s user unsettemp [server] [world]", Permission.USER_UNSET_TEMP_PERMISSION); + "/%s user unsettemp [server] [world]", Permission.USER_UNSET_TEMP_PERMISSION, + Predicate.notinRange(1, 3)); } @Override - protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { + public void execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { String node = args.get(0); if (node.contains("/") || node.contains("$")) { @@ -58,9 +60,4 @@ public class UserUnsetTempPermission extends UserSubCommand { Message.DOES_NOT_HAVE_TEMP_PERMISSION.send(sender, user.getName()); } } - - @Override - public boolean isArgLengthInvalid(int argLength) { - return argLength != 1 && argLength != 2 && argLength != 3; - } } diff --git a/common/src/main/java/me/lucko/luckperms/data/methods/FlatfileDatastore.java b/common/src/main/java/me/lucko/luckperms/data/methods/FlatfileDatastore.java index e836a7c79..b42990b24 100644 --- a/common/src/main/java/me/lucko/luckperms/data/methods/FlatfileDatastore.java +++ b/common/src/main/java/me/lucko/luckperms/data/methods/FlatfileDatastore.java @@ -503,12 +503,14 @@ public class FlatfileDatastore extends Datastore { @Override public boolean saveUUIDData(String username, UUID uuid) { + username = username.toLowerCase(); uuidCache.put(username, uuid.toString()); return true; } @Override public UUID getUUID(String username) { + username = username.toLowerCase(); if (uuidCache.get(username) == null) return null; return UUID.fromString(uuidCache.get(username)); } diff --git a/common/src/main/java/me/lucko/luckperms/data/methods/SQLDatastore.java b/common/src/main/java/me/lucko/luckperms/data/methods/SQLDatastore.java index 36a8b776c..f6812d2b9 100644 --- a/common/src/main/java/me/lucko/luckperms/data/methods/SQLDatastore.java +++ b/common/src/main/java/me/lucko/luckperms/data/methods/SQLDatastore.java @@ -80,7 +80,7 @@ abstract class SQLDatastore extends Datastore { boolean success = false; try { @Cleanup Connection connection = getConnection(); - if (connection == null) { + if (connection == null || connection.isClosed()) { throw new IllegalStateException("SQL connection is null"); } @@ -396,10 +396,11 @@ abstract class SQLDatastore extends Datastore { @Override public boolean saveUUIDData(String username, UUID uuid) { + final String u = username.toLowerCase(); boolean success = runQuery(new QueryRS(UUIDCACHE_SELECT) { @Override void onRun(PreparedStatement preparedStatement) throws SQLException { - preparedStatement.setString(1, username); + preparedStatement.setString(1, u); } @Override @@ -410,14 +411,14 @@ abstract class SQLDatastore extends Datastore { @Override void onRun(PreparedStatement preparedStatement) throws SQLException { preparedStatement.setString(1, uuid.toString()); - preparedStatement.setString(2, username); + preparedStatement.setString(2, u); } }); } else { success = runQuery(new QueryPS(UUIDCACHE_INSERT) { @Override void onRun(PreparedStatement preparedStatement) throws SQLException { - preparedStatement.setString(1, username); + preparedStatement.setString(1, u); preparedStatement.setString(2, uuid.toString()); } }); @@ -431,12 +432,13 @@ abstract class SQLDatastore extends Datastore { @Override public UUID getUUID(String username) { + final String u = username.toLowerCase(); final UUID[] uuid = {null}; boolean success = runQuery(new QueryRS(UUIDCACHE_SELECT) { @Override void onRun(PreparedStatement preparedStatement) throws SQLException { - preparedStatement.setString(1, username); + preparedStatement.setString(1, u); } @Override