diff --git a/bukkit/src/main/resources/plugin.yml b/bukkit/src/main/resources/plugin.yml index eceb1628c..a161f3526 100644 --- a/bukkit/src/main/resources/plugin.yml +++ b/bukkit/src/main/resources/plugin.yml @@ -40,6 +40,15 @@ permissions: luckperms.user.promote: true luckperms.user.demote: true luckperms.user.showpos: true + luckperms.user.chatmeta: true + luckperms.user.addprefix: true + luckperms.user.addsuffix: true + luckperms.user.removeprefix: true + luckperms.user.removesuffix: true + luckperms.user.addtempprefix: true + luckperms.user.addtempsuffix: true + luckperms.user.removetempprefix: true + luckperms.user.removetempsuffix: true luckperms.user.clear: true luckperms.group.info: true luckperms.group.listnodes: true @@ -54,6 +63,15 @@ permissions: luckperms.group.settempinherit: true luckperms.group.unsettempinherit: true luckperms.group.showtracks: true + luckperms.group.chatmeta: true + luckperms.group.addprefix: true + luckperms.group.addsuffix: true + luckperms.group.removeprefix: true + luckperms.group.removesuffix: true + luckperms.group.addtempprefix: true + luckperms.group.addtempsuffix: true + luckperms.group.removetempprefix: true + luckperms.group.removetempsuffix: true luckperms.group.clear: true luckperms.group.rename: true luckperms.track.info: true @@ -90,6 +108,15 @@ permissions: luckperms.user.promote: true luckperms.user.demote: true luckperms.user.showpos: true + luckperms.user.chatmeta: true + luckperms.user.addprefix: true + luckperms.user.addsuffix: true + luckperms.user.removeprefix: true + luckperms.user.removesuffix: true + luckperms.user.addtempprefix: true + luckperms.user.addtempsuffix: true + luckperms.user.removetempprefix: true + luckperms.user.removetempsuffix: true luckperms.user.clear: true luckperms.group.*: description: Gives access to all LuckPerms group commands @@ -107,6 +134,15 @@ permissions: luckperms.group.settempinherit: true luckperms.group.unsettempinherit: true luckperms.group.showtracks: true + luckperms.group.chatmeta: true + luckperms.group.addprefix: true + luckperms.group.addsuffix: true + luckperms.group.removeprefix: true + luckperms.group.removesuffix: true + luckperms.group.addtempprefix: true + luckperms.group.addtempsuffix: true + luckperms.group.removetempprefix: true + luckperms.group.removetempsuffix: true luckperms.group.clear: true luckperms.group.rename: true luckperms.track.*: diff --git a/common/src/main/java/me/lucko/luckperms/commands/Util.java b/common/src/main/java/me/lucko/luckperms/commands/Util.java index c4ba2300c..4a69a0712 100644 --- a/common/src/main/java/me/lucko/luckperms/commands/Util.java +++ b/common/src/main/java/me/lucko/luckperms/commands/Util.java @@ -27,6 +27,7 @@ import me.lucko.luckperms.constants.Message; import me.lucko.luckperms.constants.Patterns; import me.lucko.luckperms.utils.DateUtil; +import java.util.Comparator; import java.util.List; import java.util.Map; import java.util.UUID; @@ -161,4 +162,25 @@ public class Util { } } } + + public static synchronized MetaComparator getMetaComparator() { + if (metaComparator == null) { + metaComparator = new MetaComparator(); + } + return metaComparator; + } + + + private static MetaComparator metaComparator = null; + public class MetaComparator implements Comparator> { + + @Override + public int compare(Map.Entry o1, Map.Entry o2) { + int result = Integer.compare(o1.getKey(), o2.getKey()); + if (result == 0) { + result = o1.getValue().compareTo(o2.getValue()); + } + return result; + } + } } 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 f4170fc40..f1d79e848 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 @@ -50,6 +50,15 @@ public class GroupMainCommand extends MainCommand { .add(new GroupSetTempInherit()) .add(new GroupUnsetTempInherit()) .add(new GroupShowTracks()) + .add(new GroupChatMeta()) + .add(new GroupAddPrefix()) + .add(new GroupAddSuffix()) + .add(new GroupRemovePrefix()) + .add(new GroupRemoveSuffix()) + .add(new GroupAddTempPrefix()) + .add(new GroupAddTempSuffix()) + .add(new GroupRemoveTempPrefix()) + .add(new GroupRemoveTempSuffix()) .add(new GroupClear()) .add(new GroupRename()) .build() diff --git a/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupAddPrefix.java b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupAddPrefix.java new file mode 100644 index 000000000..d7872e46a --- /dev/null +++ b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupAddPrefix.java @@ -0,0 +1,96 @@ +/* + * Copyright (c) 2016 Lucko (Luck) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +package me.lucko.luckperms.commands.group.subcommands; + +import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.CommandResult; +import me.lucko.luckperms.commands.Predicate; +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.data.LogEntry; +import me.lucko.luckperms.exceptions.ObjectAlreadyHasException; +import me.lucko.luckperms.groups.Group; +import me.lucko.luckperms.utils.ArgumentChecker; + +import java.util.List; + +public class GroupAddPrefix extends SubCommand { + public GroupAddPrefix() { + super("addprefix", "Adds a prefix to the group", "/%s group addprefix [server] [world]", + Permission.GROUP_ADDPREFIX, Predicate.notInRange(2, 4)); + } + + @Override + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { + final String prefix = args.get(1).replace("{SPACE}", " "); + int priority; + try { + priority = Integer.parseInt(args.get(0)); + } catch (NumberFormatException e) { + Message.META_INVALID_PRIORITY.send(sender, args.get(0)); + return CommandResult.INVALID_ARGS; + } + + final String node = "prefix." + priority + "." + ArgumentChecker.escapeCharacters(prefix); + + try { + if (args.size() >= 3) { + final String server = args.get(2).toLowerCase(); + if (ArgumentChecker.checkServer(server)) { + Message.SERVER_INVALID_ENTRY.send(sender); + return CommandResult.INVALID_ARGS; + } + + if (args.size() == 3) { + group.setPermission(node, true, server); + Message.ADDPREFIX_SERVER_SUCCESS.send(sender, group.getName(), prefix, priority, server); + LogEntry.build().actor(sender).acted(group) + .action("addprefix " + priority + " " + args.get(1) + " " + server) + .build().submit(plugin, sender); + } else { + final String world = args.get(3).toLowerCase(); + group.setPermission(node, true, server, world); + Message.ADDPREFIX_SERVER_WORLD_SUCCESS.send(sender, group.getName(), prefix, priority, server, world); + LogEntry.build().actor(sender).acted(group) + .action("addprefix " + priority + " " + args.get(1) + " " + server + " " + world) + .build().submit(plugin, sender); + } + + } else { + group.setPermission(node, true); + Message.ADDPREFIX_SUCCESS.send(sender, group.getName(), prefix, priority); + LogEntry.build().actor(sender).acted(group) + .action("addprefix " + priority + " " + args.get(1)) + .build().submit(plugin, sender); + } + + save(group, sender, plugin); + return CommandResult.SUCCESS; + } catch (ObjectAlreadyHasException e) { + Message.ALREADY_HAS_PREFIX.send(sender, group.getName()); + return CommandResult.STATE_ERROR; + } + } +} diff --git a/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupAddSuffix.java b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupAddSuffix.java new file mode 100644 index 000000000..ceb7a4b42 --- /dev/null +++ b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupAddSuffix.java @@ -0,0 +1,96 @@ +/* + * Copyright (c) 2016 Lucko (Luck) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +package me.lucko.luckperms.commands.group.subcommands; + +import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.CommandResult; +import me.lucko.luckperms.commands.Predicate; +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.data.LogEntry; +import me.lucko.luckperms.exceptions.ObjectAlreadyHasException; +import me.lucko.luckperms.groups.Group; +import me.lucko.luckperms.utils.ArgumentChecker; + +import java.util.List; + +public class GroupAddSuffix extends SubCommand { + public GroupAddSuffix() { + super("addsuffix", "Adds a suffix to the group", "/%s group addsuffix [server] [world]", + Permission.GROUP_ADDSUFFIX, Predicate.notInRange(2, 4)); + } + + @Override + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { + final String suffix = args.get(1).replace("{SPACE}", " "); + int priority; + try { + priority = Integer.parseInt(args.get(0)); + } catch (NumberFormatException e) { + Message.META_INVALID_PRIORITY.send(sender, args.get(0)); + return CommandResult.INVALID_ARGS; + } + + final String node = "suffix." + priority + "." + ArgumentChecker.escapeCharacters(suffix); + + try { + if (args.size() >= 3) { + final String server = args.get(2).toLowerCase(); + if (ArgumentChecker.checkServer(server)) { + Message.SERVER_INVALID_ENTRY.send(sender); + return CommandResult.INVALID_ARGS; + } + + if (args.size() == 3) { + group.setPermission(node, true, server); + Message.ADDSUFFIX_SERVER_SUCCESS.send(sender, group.getName(), suffix, priority, server); + LogEntry.build().actor(sender).acted(group) + .action("addsuffix " + priority + " " + args.get(1) + " " + server) + .build().submit(plugin, sender); + } else { + final String world = args.get(3).toLowerCase(); + group.setPermission(node, true, server, world); + Message.ADDSUFFIX_SERVER_WORLD_SUCCESS.send(sender, group.getName(), suffix, priority, server, world); + LogEntry.build().actor(sender).acted(group) + .action("addsuffix " + priority + " " + args.get(1) + " " + server + " " + world) + .build().submit(plugin, sender); + } + + } else { + group.setPermission(node, true); + Message.ADDSUFFIX_SUCCESS.send(sender, group.getName(), suffix, priority); + LogEntry.build().actor(sender).acted(group) + .action("addsuffix " + priority + " " + args.get(1)) + .build().submit(plugin, sender); + } + + save(group, sender, plugin); + return CommandResult.SUCCESS; + } catch (ObjectAlreadyHasException e) { + Message.ALREADY_HAS_SUFFIX.send(sender, group.getName()); + return CommandResult.STATE_ERROR; + } + } +} diff --git a/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupAddTempPrefix.java b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupAddTempPrefix.java new file mode 100644 index 000000000..1ba000de3 --- /dev/null +++ b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupAddTempPrefix.java @@ -0,0 +1,114 @@ +/* + * Copyright (c) 2016 Lucko (Luck) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +package me.lucko.luckperms.commands.group.subcommands; + +import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.CommandResult; +import me.lucko.luckperms.commands.Predicate; +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.data.LogEntry; +import me.lucko.luckperms.exceptions.ObjectAlreadyHasException; +import me.lucko.luckperms.groups.Group; +import me.lucko.luckperms.utils.ArgumentChecker; +import me.lucko.luckperms.utils.DateUtil; + +import java.util.List; + +public class GroupAddTempPrefix extends SubCommand { + public GroupAddTempPrefix() { + super("addtempprefix", "Adds a prefix to the group temporarily", "/%s group addtempprefix [server] [world]", + Permission.GROUP_ADD_TEMP_PREFIX, Predicate.notInRange(3, 5)); + } + + @Override + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { + final String prefix = args.get(1).replace("{SPACE}", " "); + int priority; + try { + priority = Integer.parseInt(args.get(0)); + } catch (NumberFormatException e) { + Message.META_INVALID_PRIORITY.send(sender, args.get(0)); + return CommandResult.INVALID_ARGS; + } + + long duration; + try { + duration = Long.parseLong(args.get(2)); + } catch (NumberFormatException e) { + try { + duration = DateUtil.parseDateDiff(args.get(2), true); + } catch (DateUtil.IllegalDateException e1) { + Message.ILLEGAL_DATE_ERROR.send(sender, args.get(2)); + return CommandResult.INVALID_ARGS; + } + } + + if (DateUtil.shouldExpire(duration)) { + Message.PAST_DATE_ERROR.send(sender); + return CommandResult.INVALID_ARGS; + } + + final String node = "prefix." + priority + "." + ArgumentChecker.escapeCharacters(prefix); + + try { + if (args.size() >= 4) { + final String server = args.get(3).toLowerCase(); + if (ArgumentChecker.checkServer(server)) { + Message.SERVER_INVALID_ENTRY.send(sender); + return CommandResult.INVALID_ARGS; + } + + if (args.size() == 4) { + group.setPermission(node, true, server, duration); + Message.ADD_TEMP_PREFIX_SERVER_SUCCESS.send(sender, group.getName(), prefix, priority, server, DateUtil.formatDateDiff(duration)); + LogEntry.build().actor(sender).acted(group) + .action("addtempprefix " + priority + " " + args.get(1) + " " + duration + " " + server) + .build().submit(plugin, sender); + } else { + final String world = args.get(4).toLowerCase(); + group.setPermission(node, true, server, world, duration); + Message.ADD_TEMP_PREFIX_SERVER_WORLD_SUCCESS.send(sender, group.getName(), prefix, priority, server, world, DateUtil.formatDateDiff(duration)); + LogEntry.build().actor(sender).acted(group) + .action("addtempprefix " + priority + " " + args.get(1) + " " + duration + " " + server + " " + world) + .build().submit(plugin, sender); + } + + } else { + group.setPermission(node, true, duration); + Message.ADD_TEMP_PREFIX_SUCCESS.send(sender, group.getName(), prefix, priority, DateUtil.formatDateDiff(duration)); + LogEntry.build().actor(sender).acted(group) + .action("addtempprefix " + priority + " " + args.get(1) + " " + duration) + .build().submit(plugin, sender); + } + + save(group, sender, plugin); + return CommandResult.SUCCESS; + } catch (ObjectAlreadyHasException e) { + Message.ALREADY_HAS_PREFIX.send(sender, group.getName()); + return CommandResult.STATE_ERROR; + } + } +} diff --git a/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupAddTempSuffix.java b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupAddTempSuffix.java new file mode 100644 index 000000000..1b4f4b4df --- /dev/null +++ b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupAddTempSuffix.java @@ -0,0 +1,114 @@ +/* + * Copyright (c) 2016 Lucko (Luck) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +package me.lucko.luckperms.commands.group.subcommands; + +import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.CommandResult; +import me.lucko.luckperms.commands.Predicate; +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.data.LogEntry; +import me.lucko.luckperms.exceptions.ObjectAlreadyHasException; +import me.lucko.luckperms.groups.Group; +import me.lucko.luckperms.utils.ArgumentChecker; +import me.lucko.luckperms.utils.DateUtil; + +import java.util.List; + +public class GroupAddTempSuffix extends SubCommand { + public GroupAddTempSuffix() { + super("addtempsuffix", "Adds a suffix to the group temporarily", "/%s group addtempsuffix [server] [world]", + Permission.GROUP_ADD_TEMP_SUFFIX, Predicate.notInRange(3, 5)); + } + + @Override + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { + final String suffix = args.get(1).replace("{SPACE}", " "); + int priority; + try { + priority = Integer.parseInt(args.get(0)); + } catch (NumberFormatException e) { + Message.META_INVALID_PRIORITY.send(sender, args.get(0)); + return CommandResult.INVALID_ARGS; + } + + long duration; + try { + duration = Long.parseLong(args.get(2)); + } catch (NumberFormatException e) { + try { + duration = DateUtil.parseDateDiff(args.get(2), true); + } catch (DateUtil.IllegalDateException e1) { + Message.ILLEGAL_DATE_ERROR.send(sender, args.get(2)); + return CommandResult.INVALID_ARGS; + } + } + + if (DateUtil.shouldExpire(duration)) { + Message.PAST_DATE_ERROR.send(sender); + return CommandResult.INVALID_ARGS; + } + + final String node = "suffix." + priority + "." + ArgumentChecker.escapeCharacters(suffix); + + try { + if (args.size() >= 4) { + final String server = args.get(3).toLowerCase(); + if (ArgumentChecker.checkServer(server)) { + Message.SERVER_INVALID_ENTRY.send(sender); + return CommandResult.INVALID_ARGS; + } + + if (args.size() == 4) { + group.setPermission(node, true, server, duration); + Message.ADD_TEMP_SUFFIX_SERVER_SUCCESS.send(sender, group.getName(), suffix, priority, server, DateUtil.formatDateDiff(duration)); + LogEntry.build().actor(sender).acted(group) + .action("addtempsuffix " + priority + " " + args.get(1) + " " + duration + " " + server) + .build().submit(plugin, sender); + } else { + final String world = args.get(4).toLowerCase(); + group.setPermission(node, true, server, world, duration); + Message.ADD_TEMP_SUFFIX_SERVER_WORLD_SUCCESS.send(sender, group.getName(), suffix, priority, server, world, DateUtil.formatDateDiff(duration)); + LogEntry.build().actor(sender).acted(group) + .action("addtempsuffix " + priority + " " + args.get(1) + " " + duration + " " + server + " " + world) + .build().submit(plugin, sender); + } + + } else { + group.setPermission(node, true, duration); + Message.ADD_TEMP_SUFFIX_SUCCESS.send(sender, group.getName(), suffix, priority, DateUtil.formatDateDiff(duration)); + LogEntry.build().actor(sender).acted(group) + .action("addtempsuffix " + priority + " " + args.get(1) + " " + duration) + .build().submit(plugin, sender); + } + + save(group, sender, plugin); + return CommandResult.SUCCESS; + } catch (ObjectAlreadyHasException e) { + Message.ALREADY_HAS_SUFFIX.send(sender, group.getName()); + return CommandResult.STATE_ERROR; + } + } +} diff --git a/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupChatMeta.java b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupChatMeta.java new file mode 100644 index 000000000..868293a84 --- /dev/null +++ b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupChatMeta.java @@ -0,0 +1,89 @@ +/* + * Copyright (c) 2016 Lucko (Luck) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +package me.lucko.luckperms.commands.group.subcommands; + +import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.api.Node; +import me.lucko.luckperms.commands.*; +import me.lucko.luckperms.constants.Message; +import me.lucko.luckperms.constants.Permission; +import me.lucko.luckperms.groups.Group; + +import java.util.*; + +public class GroupChatMeta extends SubCommand { + public GroupChatMeta() { + super("chatmeta", "Displays a groups chat meta", "/%s group chatmeta", Permission.GROUP_CHATMETA, + Predicate.alwaysFalse()); + } + + @Override + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { + SortedSet> prefixes = new TreeSet<>(Util.getMetaComparator().reversed()); + SortedSet> suffixes = new TreeSet<>(Util.getMetaComparator().reversed()); + + for (Node node : group.getAllNodes(null)) { + if (!node.isSuffix() && !node.isPrefix()) { + continue; + } + + StringBuilder sb = new StringBuilder(); + if (node.isServerSpecific()) { + if (node.isWorldSpecific()) { + sb.append("&6W=").append(node.getWorld().get()).append(" "); + } + sb.append("&6S=").append(node.getServer().get()).append(" "); + } + + if (node.isPrefix()) { + sb.append(node.getPrefix().getValue()); + prefixes.add(new AbstractMap.SimpleEntry<>(node.getPrefix().getKey(), sb.toString())); + } + + if (node.isSuffix()) { + sb.append(node.getSuffix().getValue()); + suffixes.add(new AbstractMap.SimpleEntry<>(node.getSuffix().getKey(), sb.toString())); + } + } + + if (prefixes.isEmpty()) { + Message.CHAT_META_PREFIX_NONE.send(sender, group.getName()); + } else { + Message.CHAT_META_PREFIX_HEADER.send(sender, group.getName()); + for (Map.Entry e : prefixes) { + Message.CHAT_META_ENTRY.send(sender, e.getKey(), e.getValue()); + } + } + + if (suffixes.isEmpty()) { + Message.CHAT_META_SUFFIX_NONE.send(sender, group.getName()); + } else { + Message.CHAT_META_SUFFIX_HEADER.send(sender, group.getName()); + for (Map.Entry e : suffixes) { + Message.CHAT_META_ENTRY.send(sender, e.getKey(), e.getValue()); + } + } + + return CommandResult.SUCCESS; + } +} diff --git a/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupRemovePrefix.java b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupRemovePrefix.java new file mode 100644 index 000000000..90e9a8297 --- /dev/null +++ b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupRemovePrefix.java @@ -0,0 +1,96 @@ +/* + * Copyright (c) 2016 Lucko (Luck) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +package me.lucko.luckperms.commands.group.subcommands; + +import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.CommandResult; +import me.lucko.luckperms.commands.Predicate; +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.data.LogEntry; +import me.lucko.luckperms.exceptions.ObjectLacksException; +import me.lucko.luckperms.groups.Group; +import me.lucko.luckperms.utils.ArgumentChecker; + +import java.util.List; + +public class GroupRemovePrefix extends SubCommand { + public GroupRemovePrefix() { + super("removeprefix", "Removes a prefix from a group", "/%s group removeprefix [server] [world]", + Permission.GROUP_REMOVEPREFIX, Predicate.notInRange(2, 4)); + } + + @Override + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { + final String prefix = args.get(1).replace("{SPACE}", " "); + int priority; + try { + priority = Integer.parseInt(args.get(0)); + } catch (NumberFormatException e) { + Message.META_INVALID_PRIORITY.send(sender, args.get(0)); + return CommandResult.INVALID_ARGS; + } + + final String node = "prefix." + priority + "." + ArgumentChecker.escapeCharacters(prefix); + + try { + if (args.size() >= 3) { + final String server = args.get(2).toLowerCase(); + if (ArgumentChecker.checkServer(server)) { + Message.SERVER_INVALID_ENTRY.send(sender); + return CommandResult.INVALID_ARGS; + } + + if (args.size() == 3) { + group.unsetPermission(node, server); + Message.REMOVEPREFIX_SERVER_SUCCESS.send(sender, group.getName(), prefix, priority, server); + LogEntry.build().actor(sender).acted(group) + .action("removeprefix " + priority + " " + args.get(1) + " " + server) + .build().submit(plugin, sender); + } else { + final String world = args.get(3).toLowerCase(); + group.unsetPermission(node, server, world); + Message.REMOVEPREFIX_SERVER_WORLD_SUCCESS.send(sender, group.getName(), prefix, priority, server, world); + LogEntry.build().actor(sender).acted(group) + .action("removeprefix " + priority + " " + args.get(1) + " " + server + " " + world) + .build().submit(plugin, sender); + } + + } else { + group.unsetPermission(node); + Message.REMOVEPREFIX_SUCCESS.send(sender, group.getName(), prefix, priority); + LogEntry.build().actor(sender).acted(group) + .action("removeprefix " + priority + " " + args.get(1)) + .build().submit(plugin, sender); + } + + save(group, sender, plugin); + return CommandResult.SUCCESS; + } catch (ObjectLacksException e) { + Message.DOES_NOT_HAVE_PREFIX.send(sender, group.getName()); + return CommandResult.STATE_ERROR; + } + } +} diff --git a/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupRemoveSuffix.java b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupRemoveSuffix.java new file mode 100644 index 000000000..9df9202c1 --- /dev/null +++ b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupRemoveSuffix.java @@ -0,0 +1,96 @@ +/* + * Copyright (c) 2016 Lucko (Luck) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +package me.lucko.luckperms.commands.group.subcommands; + +import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.CommandResult; +import me.lucko.luckperms.commands.Predicate; +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.data.LogEntry; +import me.lucko.luckperms.exceptions.ObjectLacksException; +import me.lucko.luckperms.groups.Group; +import me.lucko.luckperms.utils.ArgumentChecker; + +import java.util.List; + +public class GroupRemoveSuffix extends SubCommand { + public GroupRemoveSuffix() { + super("removesuffix", "Removes a suffix from a group", "/%s group removesuffix [server] [world]", + Permission.GROUP_REMOVESUFFIX, Predicate.notInRange(2, 4)); + } + + @Override + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { + final String suffix = args.get(1).replace("{SPACE}", " "); + int priority; + try { + priority = Integer.parseInt(args.get(0)); + } catch (NumberFormatException e) { + Message.META_INVALID_PRIORITY.send(sender, args.get(0)); + return CommandResult.INVALID_ARGS; + } + + final String node = "suffix." + priority + "." + ArgumentChecker.escapeCharacters(suffix); + + try { + if (args.size() >= 3) { + final String server = args.get(2).toLowerCase(); + if (ArgumentChecker.checkServer(server)) { + Message.SERVER_INVALID_ENTRY.send(sender); + return CommandResult.INVALID_ARGS; + } + + if (args.size() == 3) { + group.unsetPermission(node, server); + Message.REMOVESUFFIX_SERVER_SUCCESS.send(sender, group.getName(), suffix, priority, server); + LogEntry.build().actor(sender).acted(group) + .action("removesuffix " + priority + " " + args.get(1) + " " + server) + .build().submit(plugin, sender); + } else { + final String world = args.get(3).toLowerCase(); + group.unsetPermission(node, server, world); + Message.REMOVESUFFIX_SERVER_WORLD_SUCCESS.send(sender, group.getName(), suffix, priority, server, world); + LogEntry.build().actor(sender).acted(group) + .action("removesuffix " + priority + " " + args.get(1) + " " + server + " " + world) + .build().submit(plugin, sender); + } + + } else { + group.unsetPermission(node); + Message.REMOVESUFFIX_SUCCESS.send(sender, group.getName(), suffix, priority); + LogEntry.build().actor(sender).acted(group) + .action("removesuffix " + priority + " " + args.get(1)) + .build().submit(plugin, sender); + } + + save(group, sender, plugin); + return CommandResult.SUCCESS; + } catch (ObjectLacksException e) { + Message.DOES_NOT_HAVE_SUFFIX.send(sender, group.getName()); + return CommandResult.STATE_ERROR; + } + } +} diff --git a/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupRemoveTempPrefix.java b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupRemoveTempPrefix.java new file mode 100644 index 000000000..1740a95d2 --- /dev/null +++ b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupRemoveTempPrefix.java @@ -0,0 +1,96 @@ +/* + * Copyright (c) 2016 Lucko (Luck) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +package me.lucko.luckperms.commands.group.subcommands; + +import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.CommandResult; +import me.lucko.luckperms.commands.Predicate; +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.data.LogEntry; +import me.lucko.luckperms.exceptions.ObjectLacksException; +import me.lucko.luckperms.groups.Group; +import me.lucko.luckperms.utils.ArgumentChecker; + +import java.util.List; + +public class GroupRemoveTempPrefix extends SubCommand { + public GroupRemoveTempPrefix() { + super("removetempprefix", "Removes a temporary prefix from a group", "/%s group removetempprefix [server] [world]", + Permission.GROUP_REMOVE_TEMP_PREFIX, Predicate.notInRange(2, 4)); + } + + @Override + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { + final String prefix = args.get(1).replace("{SPACE}", " "); + int priority; + try { + priority = Integer.parseInt(args.get(0)); + } catch (NumberFormatException e) { + Message.META_INVALID_PRIORITY.send(sender, args.get(0)); + return CommandResult.INVALID_ARGS; + } + + final String node = "prefix." + priority + "." + ArgumentChecker.escapeCharacters(prefix); + + try { + if (args.size() >= 3) { + final String server = args.get(2).toLowerCase(); + if (ArgumentChecker.checkServer(server)) { + Message.SERVER_INVALID_ENTRY.send(sender); + return CommandResult.INVALID_ARGS; + } + + if (args.size() == 3) { + group.unsetPermission(node, server, true); + Message.REMOVE_TEMP_PREFIX_SERVER_SUCCESS.send(sender, group.getName(), prefix, priority, server); + LogEntry.build().actor(sender).acted(group) + .action("removetempprefix " + priority + " " + args.get(1) + " " + server) + .build().submit(plugin, sender); + } else { + final String world = args.get(3).toLowerCase(); + group.unsetPermission(node, server, world, true); + Message.REMOVE_TEMP_PREFIX_SERVER_WORLD_SUCCESS.send(sender, group.getName(), prefix, priority, server, world); + LogEntry.build().actor(sender).acted(group) + .action("removetempprefix " + priority + " " + args.get(1) + " " + server + " " + world) + .build().submit(plugin, sender); + } + + } else { + group.unsetPermission(node, true); + Message.REMOVE_TEMP_PREFIX_SUCCESS.send(sender, group.getName(), prefix, priority); + LogEntry.build().actor(sender).acted(group) + .action("removetempprefix " + priority + " " + args.get(1)) + .build().submit(plugin, sender); + } + + save(group, sender, plugin); + return CommandResult.SUCCESS; + } catch (ObjectLacksException e) { + Message.DOES_NOT_HAVE_PREFIX.send(sender, group.getName()); + return CommandResult.STATE_ERROR; + } + } +} diff --git a/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupRemoveTempSuffix.java b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupRemoveTempSuffix.java new file mode 100644 index 000000000..01f1775b7 --- /dev/null +++ b/common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupRemoveTempSuffix.java @@ -0,0 +1,96 @@ +/* + * Copyright (c) 2016 Lucko (Luck) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +package me.lucko.luckperms.commands.group.subcommands; + +import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.CommandResult; +import me.lucko.luckperms.commands.Predicate; +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.data.LogEntry; +import me.lucko.luckperms.exceptions.ObjectLacksException; +import me.lucko.luckperms.groups.Group; +import me.lucko.luckperms.utils.ArgumentChecker; + +import java.util.List; + +public class GroupRemoveTempSuffix extends SubCommand { + public GroupRemoveTempSuffix() { + super("removetempsuffix", "Removes a temporary suffix from a group", "/%s group removetempsuffix [server] [world]", + Permission.GROUP_REMOVE_TEMP_SUFFIX, Predicate.notInRange(2, 4)); + } + + @Override + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { + final String suffix = args.get(1).replace("{SPACE}", " "); + int priority; + try { + priority = Integer.parseInt(args.get(0)); + } catch (NumberFormatException e) { + Message.META_INVALID_PRIORITY.send(sender, args.get(0)); + return CommandResult.INVALID_ARGS; + } + + final String node = "suffix." + priority + "." + ArgumentChecker.escapeCharacters(suffix); + + try { + if (args.size() >= 3) { + final String server = args.get(2).toLowerCase(); + if (ArgumentChecker.checkServer(server)) { + Message.SERVER_INVALID_ENTRY.send(sender); + return CommandResult.INVALID_ARGS; + } + + if (args.size() == 3) { + group.unsetPermission(node, server, true); + Message.REMOVE_TEMP_SUFFIX_SERVER_SUCCESS.send(sender, group.getName(), suffix, priority, server); + LogEntry.build().actor(sender).acted(group) + .action("removetempsuffix " + priority + " " + args.get(1) + " " + server) + .build().submit(plugin, sender); + } else { + final String world = args.get(3).toLowerCase(); + group.unsetPermission(node, server, world, true); + Message.REMOVE_TEMP_SUFFIX_SERVER_WORLD_SUCCESS.send(sender, group.getName(), suffix, priority, server, world); + LogEntry.build().actor(sender).acted(group) + .action("removetempsuffix " + priority + " " + args.get(1) + " " + server + " " + world) + .build().submit(plugin, sender); + } + + } else { + group.unsetPermission(node, true); + Message.REMOVE_TEMP_SUFFIX_SUCCESS.send(sender, group.getName(), suffix, priority); + LogEntry.build().actor(sender).acted(group) + .action("removetempsuffix " + priority + " " + args.get(1)) + .build().submit(plugin, sender); + } + + save(group, sender, plugin); + return CommandResult.SUCCESS; + } catch (ObjectLacksException e) { + Message.DOES_NOT_HAVE_SUFFIX.send(sender, group.getName()); + return CommandResult.STATE_ERROR; + } + } +} 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 c71064ad2..08e3e2178 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 @@ -57,6 +57,15 @@ public class UserMainCommand extends MainCommand { .add(new UserPromote()) .add(new UserDemote()) .add(new UserShowPos()) + .add(new UserChatMeta()) + .add(new UserAddPrefix()) + .add(new UserAddSuffix()) + .add(new UserRemovePrefix()) + .add(new UserRemoveSuffix()) + .add(new UserAddTempPrefix()) + .add(new UserAddTempSuffix()) + .add(new UserRemoveTempPrefix()) + .add(new UserRemoveTempSuffix()) .add(new UserClear()) .build() ); diff --git a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserAddPrefix.java b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserAddPrefix.java new file mode 100644 index 000000000..3a9d0b17a --- /dev/null +++ b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserAddPrefix.java @@ -0,0 +1,96 @@ +/* + * Copyright (c) 2016 Lucko (Luck) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +package me.lucko.luckperms.commands.user.subcommands; + +import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.CommandResult; +import me.lucko.luckperms.commands.Predicate; +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.data.LogEntry; +import me.lucko.luckperms.exceptions.ObjectAlreadyHasException; +import me.lucko.luckperms.users.User; +import me.lucko.luckperms.utils.ArgumentChecker; + +import java.util.List; + +public class UserAddPrefix extends SubCommand { + public UserAddPrefix() { + super("addprefix", "Adds a prefix to the user", "/%s user addprefix [server] [world]", + Permission.USER_ADDPREFIX, Predicate.notInRange(2, 4)); + } + + @Override + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { + final String prefix = args.get(1).replace("{SPACE}", " "); + int priority; + try { + priority = Integer.parseInt(args.get(0)); + } catch (NumberFormatException e) { + Message.META_INVALID_PRIORITY.send(sender, args.get(0)); + return CommandResult.INVALID_ARGS; + } + + final String node = "prefix." + priority + "." + ArgumentChecker.escapeCharacters(prefix); + + try { + if (args.size() >= 3) { + final String server = args.get(2).toLowerCase(); + if (ArgumentChecker.checkServer(server)) { + Message.SERVER_INVALID_ENTRY.send(sender); + return CommandResult.INVALID_ARGS; + } + + if (args.size() == 3) { + user.setPermission(node, true, server); + Message.ADDPREFIX_SERVER_SUCCESS.send(sender, user.getName(), prefix, priority, server); + LogEntry.build().actor(sender).acted(user) + .action("addprefix " + priority + " " + args.get(1) + " " + server) + .build().submit(plugin, sender); + } else { + final String world = args.get(3).toLowerCase(); + user.setPermission(node, true, server, world); + Message.ADDPREFIX_SERVER_WORLD_SUCCESS.send(sender, user.getName(), prefix, priority, server, world); + LogEntry.build().actor(sender).acted(user) + .action("addprefix " + priority + " " + args.get(1) + " " + server + " " + world) + .build().submit(plugin, sender); + } + + } else { + user.setPermission(node, true); + Message.ADDPREFIX_SUCCESS.send(sender, user.getName(), prefix, priority); + LogEntry.build().actor(sender).acted(user) + .action("addprefix " + priority + " " + args.get(1)) + .build().submit(plugin, sender); + } + + save(user, sender, plugin); + return CommandResult.SUCCESS; + } catch (ObjectAlreadyHasException e) { + Message.ALREADY_HAS_PREFIX.send(sender, user.getName()); + return CommandResult.STATE_ERROR; + } + } +} diff --git a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserAddSuffix.java b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserAddSuffix.java new file mode 100644 index 000000000..45f969b5c --- /dev/null +++ b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserAddSuffix.java @@ -0,0 +1,96 @@ +/* + * Copyright (c) 2016 Lucko (Luck) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +package me.lucko.luckperms.commands.user.subcommands; + +import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.CommandResult; +import me.lucko.luckperms.commands.Predicate; +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.data.LogEntry; +import me.lucko.luckperms.exceptions.ObjectAlreadyHasException; +import me.lucko.luckperms.users.User; +import me.lucko.luckperms.utils.ArgumentChecker; + +import java.util.List; + +public class UserAddSuffix extends SubCommand { + public UserAddSuffix() { + super("addsuffix", "Adds a suffix to the user", "/%s user addsuffix [server] [world]", + Permission.USER_ADDSUFFIX, Predicate.notInRange(2, 4)); + } + + @Override + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { + final String suffix = args.get(1).replace("{SPACE}", " "); + int priority; + try { + priority = Integer.parseInt(args.get(0)); + } catch (NumberFormatException e) { + Message.META_INVALID_PRIORITY.send(sender, args.get(0)); + return CommandResult.INVALID_ARGS; + } + + final String node = "suffix." + priority + "." + ArgumentChecker.escapeCharacters(suffix); + + try { + if (args.size() >= 3) { + final String server = args.get(2).toLowerCase(); + if (ArgumentChecker.checkServer(server)) { + Message.SERVER_INVALID_ENTRY.send(sender); + return CommandResult.INVALID_ARGS; + } + + if (args.size() == 3) { + user.setPermission(node, true, server); + Message.ADDSUFFIX_SERVER_SUCCESS.send(sender, user.getName(), suffix, priority, server); + LogEntry.build().actor(sender).acted(user) + .action("addsuffix " + priority + " " + args.get(1) + " " + server) + .build().submit(plugin, sender); + } else { + final String world = args.get(3).toLowerCase(); + user.setPermission(node, true, server, world); + Message.ADDSUFFIX_SERVER_WORLD_SUCCESS.send(sender, user.getName(), suffix, priority, server, world); + LogEntry.build().actor(sender).acted(user) + .action("addsuffix " + priority + " " + args.get(1) + " " + server + " " + world) + .build().submit(plugin, sender); + } + + } else { + user.setPermission(node, true); + Message.ADDSUFFIX_SUCCESS.send(sender, user.getName(), suffix, priority); + LogEntry.build().actor(sender).acted(user) + .action("addsuffix " + priority + " " + args.get(1)) + .build().submit(plugin, sender); + } + + save(user, sender, plugin); + return CommandResult.SUCCESS; + } catch (ObjectAlreadyHasException e) { + Message.ALREADY_HAS_SUFFIX.send(sender, user.getName()); + return CommandResult.STATE_ERROR; + } + } +} diff --git a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserAddTempPrefix.java b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserAddTempPrefix.java new file mode 100644 index 000000000..4a3ea2353 --- /dev/null +++ b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserAddTempPrefix.java @@ -0,0 +1,114 @@ +/* + * Copyright (c) 2016 Lucko (Luck) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +package me.lucko.luckperms.commands.user.subcommands; + +import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.CommandResult; +import me.lucko.luckperms.commands.Predicate; +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.data.LogEntry; +import me.lucko.luckperms.exceptions.ObjectAlreadyHasException; +import me.lucko.luckperms.users.User; +import me.lucko.luckperms.utils.ArgumentChecker; +import me.lucko.luckperms.utils.DateUtil; + +import java.util.List; + +public class UserAddTempPrefix extends SubCommand { + public UserAddTempPrefix() { + super("addtempprefix", "Adds a prefix to the user temporarily", "/%s user addtempprefix [server] [world]", + Permission.USER_ADD_TEMP_PREFIX, Predicate.notInRange(3, 5)); + } + + @Override + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { + final String prefix = args.get(1).replace("{SPACE}", " "); + int priority; + try { + priority = Integer.parseInt(args.get(0)); + } catch (NumberFormatException e) { + Message.META_INVALID_PRIORITY.send(sender, args.get(0)); + return CommandResult.INVALID_ARGS; + } + + long duration; + try { + duration = Long.parseLong(args.get(2)); + } catch (NumberFormatException e) { + try { + duration = DateUtil.parseDateDiff(args.get(2), true); + } catch (DateUtil.IllegalDateException e1) { + Message.ILLEGAL_DATE_ERROR.send(sender, args.get(2)); + return CommandResult.INVALID_ARGS; + } + } + + if (DateUtil.shouldExpire(duration)) { + Message.PAST_DATE_ERROR.send(sender); + return CommandResult.INVALID_ARGS; + } + + final String node = "prefix." + priority + "." + ArgumentChecker.escapeCharacters(prefix); + + try { + if (args.size() >= 4) { + final String server = args.get(3).toLowerCase(); + if (ArgumentChecker.checkServer(server)) { + Message.SERVER_INVALID_ENTRY.send(sender); + return CommandResult.INVALID_ARGS; + } + + if (args.size() == 4) { + user.setPermission(node, true, server, duration); + Message.ADD_TEMP_PREFIX_SERVER_SUCCESS.send(sender, user.getName(), prefix, priority, server, DateUtil.formatDateDiff(duration)); + LogEntry.build().actor(sender).acted(user) + .action("addtempprefix " + priority + " " + args.get(1) + " " + duration + " " + server) + .build().submit(plugin, sender); + } else { + final String world = args.get(4).toLowerCase(); + user.setPermission(node, true, server, world, duration); + Message.ADD_TEMP_PREFIX_SERVER_WORLD_SUCCESS.send(sender, user.getName(), prefix, priority, server, world, DateUtil.formatDateDiff(duration)); + LogEntry.build().actor(sender).acted(user) + .action("addtempprefix " + priority + " " + args.get(1) + " " + duration + " " + server + " " + world) + .build().submit(plugin, sender); + } + + } else { + user.setPermission(node, true, duration); + Message.ADD_TEMP_PREFIX_SUCCESS.send(sender, user.getName(), prefix, priority, DateUtil.formatDateDiff(duration)); + LogEntry.build().actor(sender).acted(user) + .action("addtempprefix " + priority + " " + args.get(1) + " " + duration) + .build().submit(plugin, sender); + } + + save(user, sender, plugin); + return CommandResult.SUCCESS; + } catch (ObjectAlreadyHasException e) { + Message.ALREADY_HAS_PREFIX.send(sender, user.getName()); + return CommandResult.STATE_ERROR; + } + } +} diff --git a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserAddTempSuffix.java b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserAddTempSuffix.java new file mode 100644 index 000000000..4f4a162c0 --- /dev/null +++ b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserAddTempSuffix.java @@ -0,0 +1,114 @@ +/* + * Copyright (c) 2016 Lucko (Luck) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +package me.lucko.luckperms.commands.user.subcommands; + +import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.CommandResult; +import me.lucko.luckperms.commands.Predicate; +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.data.LogEntry; +import me.lucko.luckperms.exceptions.ObjectAlreadyHasException; +import me.lucko.luckperms.users.User; +import me.lucko.luckperms.utils.ArgumentChecker; +import me.lucko.luckperms.utils.DateUtil; + +import java.util.List; + +public class UserAddTempSuffix extends SubCommand { + public UserAddTempSuffix() { + super("addtempsuffix", "Adds a suffix to the user temporarily", "/%s user addtempsuffix [server] [world]", + Permission.USER_ADD_TEMP_SUFFIX, Predicate.notInRange(3, 5)); + } + + @Override + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { + final String suffix = args.get(1).replace("{SPACE}", " "); + int priority; + try { + priority = Integer.parseInt(args.get(0)); + } catch (NumberFormatException e) { + Message.META_INVALID_PRIORITY.send(sender, args.get(0)); + return CommandResult.INVALID_ARGS; + } + + long duration; + try { + duration = Long.parseLong(args.get(2)); + } catch (NumberFormatException e) { + try { + duration = DateUtil.parseDateDiff(args.get(2), true); + } catch (DateUtil.IllegalDateException e1) { + Message.ILLEGAL_DATE_ERROR.send(sender, args.get(2)); + return CommandResult.INVALID_ARGS; + } + } + + if (DateUtil.shouldExpire(duration)) { + Message.PAST_DATE_ERROR.send(sender); + return CommandResult.INVALID_ARGS; + } + + final String node = "suffix." + priority + "." + ArgumentChecker.escapeCharacters(suffix); + + try { + if (args.size() >= 4) { + final String server = args.get(3).toLowerCase(); + if (ArgumentChecker.checkServer(server)) { + Message.SERVER_INVALID_ENTRY.send(sender); + return CommandResult.INVALID_ARGS; + } + + if (args.size() == 4) { + user.setPermission(node, true, server, duration); + Message.ADD_TEMP_SUFFIX_SERVER_SUCCESS.send(sender, user.getName(), suffix, priority, server, DateUtil.formatDateDiff(duration)); + LogEntry.build().actor(sender).acted(user) + .action("addtempsuffix " + priority + " " + args.get(1) + " " + duration + " " + server) + .build().submit(plugin, sender); + } else { + final String world = args.get(4).toLowerCase(); + user.setPermission(node, true, server, world, duration); + Message.ADD_TEMP_SUFFIX_SERVER_WORLD_SUCCESS.send(sender, user.getName(), suffix, priority, server, world, DateUtil.formatDateDiff(duration)); + LogEntry.build().actor(sender).acted(user) + .action("addtempsuffix " + priority + " " + args.get(1) + " " + duration + " " + server + " " + world) + .build().submit(plugin, sender); + } + + } else { + user.setPermission(node, true, duration); + Message.ADD_TEMP_SUFFIX_SUCCESS.send(sender, user.getName(), suffix, priority, DateUtil.formatDateDiff(duration)); + LogEntry.build().actor(sender).acted(user) + .action("addtempsuffix " + priority + " " + args.get(1) + " " + duration) + .build().submit(plugin, sender); + } + + save(user, sender, plugin); + return CommandResult.SUCCESS; + } catch (ObjectAlreadyHasException e) { + Message.ALREADY_HAS_SUFFIX.send(sender, user.getName()); + return CommandResult.STATE_ERROR; + } + } +} diff --git a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserChatMeta.java b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserChatMeta.java new file mode 100644 index 000000000..2e47f7b0c --- /dev/null +++ b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserChatMeta.java @@ -0,0 +1,93 @@ +/* + * Copyright (c) 2016 Lucko (Luck) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +package me.lucko.luckperms.commands.user.subcommands; + +import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.api.Node; +import me.lucko.luckperms.commands.*; +import me.lucko.luckperms.constants.Message; +import me.lucko.luckperms.constants.Permission; +import me.lucko.luckperms.users.User; + +import java.util.AbstractMap.SimpleEntry; +import java.util.List; +import java.util.Map; +import java.util.SortedSet; +import java.util.TreeSet; + +public class UserChatMeta extends SubCommand { + public UserChatMeta() { + super("chatmeta", "Displays a users chat meta", "/%s user chatmeta", Permission.USER_CHATMETA, + Predicate.alwaysFalse()); + } + + @Override + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { + SortedSet> prefixes = new TreeSet<>(Util.getMetaComparator().reversed()); + SortedSet> suffixes = new TreeSet<>(Util.getMetaComparator().reversed()); + + for (Node node : user.getAllNodes(null)) { + if (!node.isSuffix() && !node.isPrefix()) { + continue; + } + + StringBuilder sb = new StringBuilder(); + if (node.isServerSpecific()) { + if (node.isWorldSpecific()) { + sb.append("&6W=").append(node.getWorld().get()).append(" "); + } + sb.append("&6S=").append(node.getServer().get()).append(" "); + } + + if (node.isPrefix()) { + sb.append(node.getPrefix().getValue()); + prefixes.add(new SimpleEntry<>(node.getPrefix().getKey(), sb.toString())); + } + + if (node.isSuffix()) { + sb.append(node.getSuffix().getValue()); + suffixes.add(new SimpleEntry<>(node.getSuffix().getKey(), sb.toString())); + } + } + + if (prefixes.isEmpty()) { + Message.CHAT_META_PREFIX_NONE.send(sender, user.getName()); + } else { + Message.CHAT_META_PREFIX_HEADER.send(sender, user.getName()); + for (Map.Entry e : prefixes) { + Message.CHAT_META_ENTRY.send(sender, e.getKey(), e.getValue()); + } + } + + if (suffixes.isEmpty()) { + Message.CHAT_META_SUFFIX_NONE.send(sender, user.getName()); + } else { + Message.CHAT_META_SUFFIX_HEADER.send(sender, user.getName()); + for (Map.Entry e : suffixes) { + Message.CHAT_META_ENTRY.send(sender, e.getKey(), e.getValue()); + } + } + + return CommandResult.SUCCESS; + } +} diff --git a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserRemovePrefix.java b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserRemovePrefix.java new file mode 100644 index 000000000..20713ce8f --- /dev/null +++ b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserRemovePrefix.java @@ -0,0 +1,96 @@ +/* + * Copyright (c) 2016 Lucko (Luck) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +package me.lucko.luckperms.commands.user.subcommands; + +import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.CommandResult; +import me.lucko.luckperms.commands.Predicate; +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.data.LogEntry; +import me.lucko.luckperms.exceptions.ObjectLacksException; +import me.lucko.luckperms.users.User; +import me.lucko.luckperms.utils.ArgumentChecker; + +import java.util.List; + +public class UserRemovePrefix extends SubCommand { + public UserRemovePrefix() { + super("removeprefix", "Removes a prefix from a user", "/%s user removeprefix [server] [world]", + Permission.USER_REMOVEPREFIX, Predicate.notInRange(2, 4)); + } + + @Override + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { + final String prefix = args.get(1).replace("{SPACE}", " "); + int priority; + try { + priority = Integer.parseInt(args.get(0)); + } catch (NumberFormatException e) { + Message.META_INVALID_PRIORITY.send(sender, args.get(0)); + return CommandResult.INVALID_ARGS; + } + + final String node = "prefix." + priority + "." + ArgumentChecker.escapeCharacters(prefix); + + try { + if (args.size() >= 3) { + final String server = args.get(2).toLowerCase(); + if (ArgumentChecker.checkServer(server)) { + Message.SERVER_INVALID_ENTRY.send(sender); + return CommandResult.INVALID_ARGS; + } + + if (args.size() == 3) { + user.unsetPermission(node, server); + Message.REMOVEPREFIX_SERVER_SUCCESS.send(sender, user.getName(), prefix, priority, server); + LogEntry.build().actor(sender).acted(user) + .action("removeprefix " + priority + " " + args.get(1) + " " + server) + .build().submit(plugin, sender); + } else { + final String world = args.get(3).toLowerCase(); + user.unsetPermission(node, server, world); + Message.REMOVEPREFIX_SERVER_WORLD_SUCCESS.send(sender, user.getName(), prefix, priority, server, world); + LogEntry.build().actor(sender).acted(user) + .action("removeprefix " + priority + " " + args.get(1) + " " + server + " " + world) + .build().submit(plugin, sender); + } + + } else { + user.unsetPermission(node); + Message.REMOVEPREFIX_SUCCESS.send(sender, user.getName(), prefix, priority); + LogEntry.build().actor(sender).acted(user) + .action("removeprefix " + priority + " " + args.get(1)) + .build().submit(plugin, sender); + } + + save(user, sender, plugin); + return CommandResult.SUCCESS; + } catch (ObjectLacksException e) { + Message.DOES_NOT_HAVE_PREFIX.send(sender, user.getName()); + return CommandResult.STATE_ERROR; + } + } +} diff --git a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserRemoveSuffix.java b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserRemoveSuffix.java new file mode 100644 index 000000000..92ebaab17 --- /dev/null +++ b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserRemoveSuffix.java @@ -0,0 +1,96 @@ +/* + * Copyright (c) 2016 Lucko (Luck) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +package me.lucko.luckperms.commands.user.subcommands; + +import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.CommandResult; +import me.lucko.luckperms.commands.Predicate; +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.data.LogEntry; +import me.lucko.luckperms.exceptions.ObjectLacksException; +import me.lucko.luckperms.users.User; +import me.lucko.luckperms.utils.ArgumentChecker; + +import java.util.List; + +public class UserRemoveSuffix extends SubCommand { + public UserRemoveSuffix() { + super("removesuffix", "Removes a suffix from a user", "/%s user removesuffix [server] [world]", + Permission.USER_REMOVESUFFIX, Predicate.notInRange(2, 4)); + } + + @Override + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { + final String suffix = args.get(1).replace("{SPACE}", " "); + int priority; + try { + priority = Integer.parseInt(args.get(0)); + } catch (NumberFormatException e) { + Message.META_INVALID_PRIORITY.send(sender, args.get(0)); + return CommandResult.INVALID_ARGS; + } + + final String node = "suffix." + priority + "." + ArgumentChecker.escapeCharacters(suffix); + + try { + if (args.size() >= 3) { + final String server = args.get(2).toLowerCase(); + if (ArgumentChecker.checkServer(server)) { + Message.SERVER_INVALID_ENTRY.send(sender); + return CommandResult.INVALID_ARGS; + } + + if (args.size() == 3) { + user.unsetPermission(node, server); + Message.REMOVESUFFIX_SERVER_SUCCESS.send(sender, user.getName(), suffix, priority, server); + LogEntry.build().actor(sender).acted(user) + .action("removesuffix " + priority + " " + args.get(1) + " " + server) + .build().submit(plugin, sender); + } else { + final String world = args.get(3).toLowerCase(); + user.unsetPermission(node, server, world); + Message.REMOVESUFFIX_SERVER_WORLD_SUCCESS.send(sender, user.getName(), suffix, priority, server, world); + LogEntry.build().actor(sender).acted(user) + .action("removesuffix " + priority + " " + args.get(1) + " " + server + " " + world) + .build().submit(plugin, sender); + } + + } else { + user.unsetPermission(node); + Message.REMOVESUFFIX_SUCCESS.send(sender, user.getName(), suffix, priority); + LogEntry.build().actor(sender).acted(user) + .action("removesuffix " + priority + " " + args.get(1)) + .build().submit(plugin, sender); + } + + save(user, sender, plugin); + return CommandResult.SUCCESS; + } catch (ObjectLacksException e) { + Message.DOES_NOT_HAVE_SUFFIX.send(sender, user.getName()); + return CommandResult.STATE_ERROR; + } + } +} diff --git a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserRemoveTempPrefix.java b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserRemoveTempPrefix.java new file mode 100644 index 000000000..b93627840 --- /dev/null +++ b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserRemoveTempPrefix.java @@ -0,0 +1,96 @@ +/* + * Copyright (c) 2016 Lucko (Luck) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +package me.lucko.luckperms.commands.user.subcommands; + +import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.CommandResult; +import me.lucko.luckperms.commands.Predicate; +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.data.LogEntry; +import me.lucko.luckperms.exceptions.ObjectLacksException; +import me.lucko.luckperms.users.User; +import me.lucko.luckperms.utils.ArgumentChecker; + +import java.util.List; + +public class UserRemoveTempPrefix extends SubCommand { + public UserRemoveTempPrefix() { + super("removetempprefix", "Removes a temporary prefix from a user", "/%s user removetempprefix [server] [world]", + Permission.USER_REMOVE_TEMP_PREFIX, Predicate.notInRange(2, 4)); + } + + @Override + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { + final String prefix = args.get(1).replace("{SPACE}", " "); + int priority; + try { + priority = Integer.parseInt(args.get(0)); + } catch (NumberFormatException e) { + Message.META_INVALID_PRIORITY.send(sender, args.get(0)); + return CommandResult.INVALID_ARGS; + } + + final String node = "prefix." + priority + "." + ArgumentChecker.escapeCharacters(prefix); + + try { + if (args.size() >= 3) { + final String server = args.get(2).toLowerCase(); + if (ArgumentChecker.checkServer(server)) { + Message.SERVER_INVALID_ENTRY.send(sender); + return CommandResult.INVALID_ARGS; + } + + if (args.size() == 3) { + user.unsetPermission(node, server, true); + Message.REMOVE_TEMP_PREFIX_SERVER_SUCCESS.send(sender, user.getName(), prefix, priority, server); + LogEntry.build().actor(sender).acted(user) + .action("removetempprefix " + priority + " " + args.get(1) + " " + server) + .build().submit(plugin, sender); + } else { + final String world = args.get(3).toLowerCase(); + user.unsetPermission(node, server, world, true); + Message.REMOVE_TEMP_PREFIX_SERVER_WORLD_SUCCESS.send(sender, user.getName(), prefix, priority, server, world); + LogEntry.build().actor(sender).acted(user) + .action("removetempprefix " + priority + " " + args.get(1) + " " + server + " " + world) + .build().submit(plugin, sender); + } + + } else { + user.unsetPermission(node, true); + Message.REMOVE_TEMP_PREFIX_SUCCESS.send(sender, user.getName(), prefix, priority); + LogEntry.build().actor(sender).acted(user) + .action("removetempprefix " + priority + " " + args.get(1)) + .build().submit(plugin, sender); + } + + save(user, sender, plugin); + return CommandResult.SUCCESS; + } catch (ObjectLacksException e) { + Message.DOES_NOT_HAVE_PREFIX.send(sender, user.getName()); + return CommandResult.STATE_ERROR; + } + } +} diff --git a/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserRemoveTempSuffix.java b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserRemoveTempSuffix.java new file mode 100644 index 000000000..5c65a1551 --- /dev/null +++ b/common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserRemoveTempSuffix.java @@ -0,0 +1,96 @@ +/* + * Copyright (c) 2016 Lucko (Luck) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +package me.lucko.luckperms.commands.user.subcommands; + +import me.lucko.luckperms.LuckPermsPlugin; +import me.lucko.luckperms.commands.CommandResult; +import me.lucko.luckperms.commands.Predicate; +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.data.LogEntry; +import me.lucko.luckperms.exceptions.ObjectLacksException; +import me.lucko.luckperms.users.User; +import me.lucko.luckperms.utils.ArgumentChecker; + +import java.util.List; + +public class UserRemoveTempSuffix extends SubCommand { + public UserRemoveTempSuffix() { + super("removetempsuffix", "Removes a temporary suffix from a user", "/%s user removetempsuffix [server] [world]", + Permission.USER_REMOVE_TEMP_SUFFIX, Predicate.notInRange(2, 4)); + } + + @Override + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { + final String suffix = args.get(1).replace("{SPACE}", " "); + int priority; + try { + priority = Integer.parseInt(args.get(0)); + } catch (NumberFormatException e) { + Message.META_INVALID_PRIORITY.send(sender, args.get(0)); + return CommandResult.INVALID_ARGS; + } + + final String node = "suffix." + priority + "." + ArgumentChecker.escapeCharacters(suffix); + + try { + if (args.size() >= 3) { + final String server = args.get(2).toLowerCase(); + if (ArgumentChecker.checkServer(server)) { + Message.SERVER_INVALID_ENTRY.send(sender); + return CommandResult.INVALID_ARGS; + } + + if (args.size() == 3) { + user.unsetPermission(node, server, true); + Message.REMOVE_TEMP_SUFFIX_SERVER_SUCCESS.send(sender, user.getName(), suffix, priority, server); + LogEntry.build().actor(sender).acted(user) + .action("removetempsuffix " + priority + " " + args.get(1) + " " + server) + .build().submit(plugin, sender); + } else { + final String world = args.get(3).toLowerCase(); + user.unsetPermission(node, server, world, true); + Message.REMOVE_TEMP_SUFFIX_SERVER_WORLD_SUCCESS.send(sender, user.getName(), suffix, priority, server, world); + LogEntry.build().actor(sender).acted(user) + .action("removetempsuffix " + priority + " " + args.get(1) + " " + server + " " + world) + .build().submit(plugin, sender); + } + + } else { + user.unsetPermission(node, true); + Message.REMOVE_TEMP_SUFFIX_SUCCESS.send(sender, user.getName(), suffix, priority); + LogEntry.build().actor(sender).acted(user) + .action("removetempsuffix " + priority + " " + args.get(1)) + .build().submit(plugin, sender); + } + + save(user, sender, plugin); + return CommandResult.SUCCESS; + } catch (ObjectLacksException e) { + Message.DOES_NOT_HAVE_SUFFIX.send(sender, user.getName()); + return CommandResult.STATE_ERROR; + } + } +} diff --git a/common/src/main/java/me/lucko/luckperms/constants/Message.java b/common/src/main/java/me/lucko/luckperms/constants/Message.java index f867abdf8..64e865aad 100644 --- a/common/src/main/java/me/lucko/luckperms/constants/Message.java +++ b/common/src/main/java/me/lucko/luckperms/constants/Message.java @@ -168,6 +168,46 @@ public enum Message { ILLEGAL_DATE_ERROR("Could not parse date '%s'.", true), PAST_DATE_ERROR("You cannot set a date in the past!", true), + CHAT_META_PREFIX_HEADER("&e%s's Prefixes", true), + CHAT_META_SUFFIX_HEADER("&e%s's Suffixes", true), + CHAT_META_ENTRY("&d-> &e%s &6- &f\"%s&f\"", true), + CHAT_META_PREFIX_NONE("&e%s has no prefixes.", true), + CHAT_META_SUFFIX_NONE("&e%s has no suffixes.", true), + + META_INVALID_PRIORITY("Invalid priority '%s'. Expected a number.", true), + ALREADY_HAS_PREFIX("%s already has that prefix set.", true), + ALREADY_HAS_SUFFIX("%s already has that suffix set.", true), + DOES_NOT_HAVE_PREFIX("%s doesn't have that prefix set.", true), + DOES_NOT_HAVE_SUFFIX("%s doesn't have that suffix set.", true), + + ADDPREFIX_SUCCESS("&b%s&a had prefix &f\"%s&f\"&a set at a priority of &b%s&a.", true), + ADDPREFIX_SERVER_SUCCESS("&b%s&a had prefix &f\"%s&f\"&a set at a priority of &b%s&a on server &b%s&a.", true), + ADDPREFIX_SERVER_WORLD_SUCCESS("&b%s&a had prefix &f\"%s&f\"&a set at a priority of &b%s&a on server &b%s&a, world &b%s&a.", true), + REMOVEPREFIX_SUCCESS("&b%s&a had prefix &f\"%s&f\"&a at priority &b%s&a removed.", true), + REMOVEPREFIX_SERVER_SUCCESS("&b%s&a had prefix &f\"%s&f\"&a at priority &b%s&a removed on server &b%s&a.", true), + REMOVEPREFIX_SERVER_WORLD_SUCCESS("&b%s&a had prefix &f\"%s&f\"&a at priority &b%s&a removed on server &b%s&a, world &b%s&a.", true), + + ADDSUFFIX_SUCCESS("&b%s&a had suffix &f\"%s&f\"&a set at a priority of &b%s&a.", true), + ADDSUFFIX_SERVER_SUCCESS("&b%s&a had suffix &f\"%s&f\"&a set at a priority of &b%s&a on server &b%s&a.", true), + ADDSUFFIX_SERVER_WORLD_SUCCESS("&b%s&a had suffix &f\"%s&f\"&a set at a priority of &b%s&a on server &b%s&a, world &b%s&a.", true), + REMOVESUFFIX_SUCCESS("&b%s&a had suffix &f\"%s&f\"&a at priority &b%s&a removed.", true), + REMOVESUFFIX_SERVER_SUCCESS("&b%s&a had suffix &f\"%s&f\"&a at priority &b%s&a removed on server &b%s&a.", true), + REMOVESUFFIX_SERVER_WORLD_SUCCESS("&b%s&a had suffix &f\"%s&f\"&a at priority &b%s&a removed on server &b%s&a, world &b%s&a.", true), + + ADD_TEMP_PREFIX_SUCCESS("&b%s&a had prefix &f\"%s&f\"&a set at a priority of &b%s&a for a duration of &b%s&a.", true), + ADD_TEMP_PREFIX_SERVER_SUCCESS("&b%s&a had prefix &f\"%s&f\"&a set at a priority of &b%s&a on server &b%s&a, for a duration of &b%s&a.", true), + ADD_TEMP_PREFIX_SERVER_WORLD_SUCCESS("&b%s&a had prefix &f\"%s&f\"&a set at a priority of &b%s&a on server &b%s&a, world &b%s&a, for a duration of &b%s&a.", true), + REMOVE_TEMP_PREFIX_SUCCESS("&b%s&a had temporary prefix &f\"%s&f\"&a at priority &b%s&a removed.", true), + REMOVE_TEMP_PREFIX_SERVER_SUCCESS("&b%s&a had temporary prefix &f\"%s&f\"&a at priority &b%s&a removed on server &b%s&a.", true), + REMOVE_TEMP_PREFIX_SERVER_WORLD_SUCCESS("&b%s&a had temporary prefix &f\"%s&f\"&a at priority &b%s&a removed on server &b%s&a, world &b%s&a.", true), + + ADD_TEMP_SUFFIX_SUCCESS("&b%s&a had suffix &f\"%s&f\"&a set at a priority of &b%s&a for a duration of &b%s&a.", true), + ADD_TEMP_SUFFIX_SERVER_SUCCESS("&b%s&a had suffix &f\"%s&f\"&a set at a priority of &b%s&a on server &b%s&a, for a duration of &b%s&a.", true), + ADD_TEMP_SUFFIX_SERVER_WORLD_SUCCESS("&b%s&a had suffix &f\"%s&f\"&a set at a priority of &b%s&a on server &b%s&a, world &b%s&a, for a duration of &b%s&a.", true), + REMOVE_TEMP_SUFFIX_SUCCESS("&b%s&a had temporary suffix &f\"%s&f\"&a at priority &b%s&a removed.", true), + REMOVE_TEMP_SUFFIX_SERVER_SUCCESS("&b%s&a had temporary suffix &f\"%s&f\"&a at priority &b%s&a removed on server &b%s&a.", true), + REMOVE_TEMP_SUFFIX_SERVER_WORLD_SUCCESS("&b%s&a had temporary suffix &f\"%s&f\"&a at priority &b%s&a removed on server &b%s&a, world &b%s&a.", true), + USER_INFO( PREFIX + "&d-> &eUser: &6%s" + "\n" + PREFIX + "&d-> &eUUID: &6%s" + "\n" + diff --git a/common/src/main/java/me/lucko/luckperms/constants/Permission.java b/common/src/main/java/me/lucko/luckperms/constants/Permission.java index ac816d706..c783a2589 100644 --- a/common/src/main/java/me/lucko/luckperms/constants/Permission.java +++ b/common/src/main/java/me/lucko/luckperms/constants/Permission.java @@ -60,6 +60,15 @@ public enum Permission { USER_PROMOTE("promote", "user"), USER_DEMOTE("demote", "user"), USER_SHOWPOS("showpos", "user"), + USER_CHATMETA("chatmeta", "user"), + USER_ADDPREFIX("addprefix", "user"), + USER_REMOVEPREFIX("removeprefix", "user"), + USER_ADDSUFFIX("addsuffix", "user"), + USER_REMOVESUFFIX("removesuffix", "user"), + USER_ADD_TEMP_PREFIX("addtempprefix", "user"), + USER_REMOVE_TEMP_PREFIX("removetempprefix", "user"), + USER_ADD_TEMP_SUFFIX("addtempsuffix", "user"), + USER_REMOVE_TEMP_SUFFIX("removetempsuffix", "user"), USER_CLEAR("clear", "user"), GROUP_INFO("info", "group"), @@ -75,6 +84,15 @@ public enum Permission { GROUP_SET_TEMP_INHERIT("settempinherit", "group"), GROUP_UNSET_TEMP_INHERIT("unsettempinherit", "group"), GROUP_SHOWTRACKS("showtracks", "group"), + GROUP_CHATMETA("chatmeta", "group"), + GROUP_ADDPREFIX("addprefix", "group"), + GROUP_REMOVEPREFIX("removeprefix", "group"), + GROUP_ADDSUFFIX("addsuffix", "group"), + GROUP_REMOVESUFFIX("removesuffix", "group"), + GROUP_ADD_TEMP_PREFIX("addtempprefix", "group"), + GROUP_REMOVE_TEMP_PREFIX("removetempprefix", "group"), + GROUP_ADD_TEMP_SUFFIX("addtempsuffix", "group"), + GROUP_REMOVE_TEMP_SUFFIX("removetempsuffix", "group"), GROUP_CLEAR("clear", "group"), GROUP_RENAME("rename", "group"),