Java 类org.bukkit.permissions.Permission 实例源码

@EventHandler
public void onCraft(CraftItemEvent e)
{
    Player p = (Player) e.getWhoClicked();
    if(e.getRecipe() instanceof ShapedRecipe)
    {
        ShapedRecipe sr = (ShapedRecipe) e.getRecipe();
        if(Bukkit.getBukkitVersion().contains("1.11"))
        {
            for(BagBase  bb : Util.getBags())
            {
                if(((ShapedRecipe)bb.getRecipe()).getShape().equals(sr.getShape()))
                {
                    if(!hasPermission(new Permission("bag.craft." + bb.getName(), PermissionDefault.TRUE), p))
                    e.setCancelled(true);                   
                }
            }
        }
        else
        if(sr.getKey().getNamespace().startsWith("bag_"))
        {
            if(!hasPermission(new Permission("bag.craft." + sr.getKey().getKey(), PermissionDefault.TRUE), p))
            e.setCancelled(true);
        }
    }
}

@Override
public void onEnable() {
    // Ensure parsing errors show in the console on Lobby servers,
    // since PGM is not around to do that.
    mapdevLogger.setUseParentHandlers(true);

    this.getServer().getPluginManager().registerEvents(new EnvironmentControlListener(), this);
    this.getServer().getPluginManager().registerEvents(new Gizmos(), this);
    this.getServer().getMessenger().registerOutgoingPluginChannel(this, BUNGEE_CHANNEL);

    this.setupScoreboard();
    this.loadConfig();

    for(Gizmo gizmo : Gizmos.gizmos) {
        Bukkit.getPluginManager().addPermission(new Permission(gizmo.getPermissionNode(), PermissionDefault.FALSE));
    }

    Settings settings = new Settings(this);
    settings.register();

    navigatorInterface.setOpenButtonSlot(Slot.Hotbar.forPosition(0));
}

@Override
public void enable() {
    final PermissionAttachment attachment = Bukkit.getConsoleSender().addAttachment(plugin);
    Stream.of(
        PERMISSION,
        PERMISSION_GET,
        PERMISSION_SET,
        PERMISSION_ANY,
        PERMISSION_ANY_GET,
        PERMISSION_ANY_SET,
        PERMISSION_IMMEDIATE
    ).forEach(name -> {
        final Permission permission = new Permission(name, PermissionDefault.FALSE);
        pluginManager.addPermission(permission);
        attachment.setPermission(permission, true);
    });
}

public static void setupPermissions(NavyCraft p) {
    plugin = p;
    PluginManager pm = NavyCraft.instance.getServer().getPluginManager();
    if(pm != null) {
        pm.addPermission(new Permission("navycraft.periscope.use"));
        pm.addPermission(new Permission("navycraft.aa-gun.use"));
        pm.addPermission(new Permission("navycraft.periscope.create"));
        pm.addPermission(new Permission("navycraft.aa-gun.create"));

        for (CraftType type : CraftType.craftTypes) 
        {
            pm.addPermission(new Permission("navycraft." + type.name + ".release"));
            pm.addPermission(new Permission("navycraft." + type.name + ".info"));
            pm.addPermission(new Permission("navycraft." + type.name + ".takeover"));
            pm.addPermission(new Permission("navycraft." + type.name + ".start"));
            pm.addPermission(new Permission("navycraft." + type.name + ".create"));
            pm.addPermission(new Permission("navycraft." + type.name + ".sink"));
            pm.addPermission(new Permission("navycraft." + type.name + ".remove"));
        }
    }
}

private boolean execBeh(String beh){
    String[] arr = beh.split(" ");
    String cmd = arr[0];
    String[] args = Arrays.copyOfRange(arr, 1, arr.length);
    String argsas = "";
    for(String a : args){
        argsas = argsas + a + " ";
    }
    switch(cmd){
        case "print":
            getLogger().info(argsas);
            return true;
        case "addperm":
            PluginManager pm = Bukkit.getServer().getPluginManager();
            pm.addPermission(new Permission(argsas));
            return true;
        case "//":
            return true;
        default:
            return false;
    }
}

private static void resolve(ImmutableMap.Builder<Map.Entry<String, Boolean>, ImmutableMap<String, Boolean>> accumulator, Permission permission, boolean value) {

        // accumulator for the child permissions being looked up
        Map<String, Boolean> children = new HashMap<>();

        // resolve children for the permission, so pass a map containing just the permission being looked up.
        resolveChildren(children, Collections.singletonMap(permission.getName(), value), false);

        // remove self
        children.remove(permission.getName(), value);

        // only register the children if there are any.
        if (!children.isEmpty()) {
            accumulator.put(Maps.immutableEntry(permission.getName().toLowerCase(), value), ImmutableMap.copyOf(children));
        }
    }

private static void resolveChildren(Map<String, Boolean> accumulator, Map<String, Boolean> children, boolean invert) {
    // iterate through the current known children.
    // the first time this method is called for a given permission, the children map will contain only the permission itself.
    for (Map.Entry<String, Boolean> e : children.entrySet()) {
        if (accumulator.containsKey(e.getKey())) {
            continue; // Prevent infinite loops
        }

        // xor the value using the parent (bukkit logic, not mine)
        boolean value = e.getValue() ^ invert;
        accumulator.put(e.getKey().toLowerCase(), value);

        // lookup any deeper children & resolve if present
        Permission perm = Bukkit.getServer().getPluginManager().getPermission(e.getKey());
        if (perm != null) {
            resolveChildren(accumulator, perm.getChildren(), !value);
        }
    }
}

private static void calculateChildPermissions(Map<String, Boolean> accumulator, DummyPermissible p, Map<String, Boolean> children, boolean invert) {
    for (Map.Entry<String, Boolean> e : children.entrySet()) {
        if (accumulator.containsKey(e.getKey())) {
            continue; // Prevent infinite loops
        }

        // xor the value using the parent (bukkit logic, not mine)
        boolean value = e.getValue() ^ invert;

        accumulator.put(e.getKey().toLowerCase(), value);
        pm().subscribeToPermission(e.getKey(), p);

        // lookup any deeper children & resolve if present
        Permission perm = pm().getPermission(e.getKey());
        if (perm != null) {
            calculateChildPermissions(accumulator, p, perm.getChildren(), !value);
        }
    }
}

@Override
public boolean isPermissionSet(Permission permission) {
    if (permission == null) {
        throw new NullPointerException("permission");
    }

    Tristate ts = this.user.getCachedData().getPermissionData(calculateContexts()).getPermissionValue(permission.getName(), CheckOrigin.PLATFORM_LOOKUP_CHECK);
    if (ts != Tristate.UNDEFINED) {
        return true;
    }

    if (!this.plugin.getConfiguration().get(ConfigKeys.APPLY_BUKKIT_DEFAULT_PERMISSIONS)) {
        return Permission.DEFAULT_PERMISSION.getValue(isOp());
    } else {
        return permission.getDefault().getValue(isOp());
    }
}

@Override
public boolean hasPermission(Permission permission) {
    if (permission == null) {
        throw new NullPointerException("permission");
    }

    Tristate ts = this.user.getCachedData().getPermissionData(calculateContexts()).getPermissionValue(permission.getName(), CheckOrigin.PLATFORM_PERMISSION_CHECK);
    if (ts != Tristate.UNDEFINED) {
        return ts.asBoolean();
    }

    if (!this.plugin.getConfiguration().get(ConfigKeys.APPLY_BUKKIT_DEFAULT_PERMISSIONS)) {
        return Permission.DEFAULT_PERMISSION.getValue(isOp());
    } else {
        return permission.getDefault().getValue(isOp());
    }
}

public UpdateChecker(Plugin plugin, String spigotFullId) {
    this.plugin = plugin;
    this.spigotId = spigotFullId;
    try {
        this.spigotUrl = new URL("https://www.spigotmc.org/resources/" + spigotId + "/");
    } catch (MalformedURLException e) {
        throw new IllegalArgumentException("Invalid spigot id: " + spigotId);
    }
    this.logger = plugin.getLogger();
    permission = new Permission(plugin.getName() + ".update");
    permission.setDefault(PermissionDefault.OP);
    Bukkit.getPluginManager().addPermission(permission);
    setInterval(20*60*30);//30 minutes
    message = buildMessage();
}

@Override
public void calcPermissions() {
    Permission perm = DownloadableUpdateChecker.this.getPermission();
    if(perm != null) {
        setPermission(perm);
        if (getParent() != null)
            perm.addParent(getParent().getAnyPerm(), true);
    }
}

public void calculatePermissions() {
    WithPermission perm = getClass().getAnnotation(WithPermission.class);
    if (perm != null) {
        String path;
        if (parent != null) {
            if (parent.getPermission() == null)
                return;
            path = parent.getPermission().getName() + '.' + perm.value();
        } else path = perm.value();
        permission = new Permission(path, perm.value(), perm.defaultPermission().get(this));
        if (parent != null)
            permission.addParent(parent.getAnyPerm(), true);
    }
}

public FunctionCommandParameter(FunctionCommand command, Parameter parameter) {
    super(command);
    WithName nameAnnotation = parameter.getAnnotation(WithName.class);
    if (nameAnnotation != null) {
        setName(nameAnnotation.value());
    }
    WithOptional optionalAnnotation = parameter.getAnnotation(WithOptional.class);
    if (optionalAnnotation != null) {
        setOptional(true);
        setDefaultValue(optionalAnnotation.value());
    }
    WithPermission permissionAnnotation = parameter.getAnnotation(WithPermission.class);
    if (permissionAnnotation != null) {
        StringJoiner path = new StringJoiner(".");
        if (command.getPermission() != null) {
            path.add(command.getPermission().getName());
        }
        path.add(permissionAnnotation.value());
        Permission permission = new Permission(path.toString());
        if (command.getPermission() != null) {
            permission.addParent(command.getPermission(), true);
        }
        permission.setDescription(permissionAnnotation.value());
        setPermission(permission);
    }
    this.parameter = parameter;
}

public boolean hasPermission(Permission perm, Player p)
{
    if(p.hasPermission(perm))
    {
        return true;
    }
    else
    {
        p.sendMessage(Translation.get("not_allowed"));
        return false;
    }
}

public boolean hasPermission(Permission perm, Player p)
{
    if(p.hasPermission(perm))
    {
        return true;
    }
    else
    {
        p.sendMessage(Translation.get("not_allowed"));
        return false;
    }
}

@Inject ChannelMatchModule(Match match, Plugin plugin) {
    this.matchListeningPermission = new Permission("pgm.chat.all." + match.getId() + ".receive", PermissionDefault.FALSE);

    final OnlinePlayerMapAdapter<Boolean> map = new OnlinePlayerMapAdapter<>(plugin);
    map.enable();
    this.teamChatters = new DefaultMapAdapter<>(map, true, false);
}

@Override
protected void configure() {
    requestStaticInjection(RaindropUtil.class);

    new PluginFacetBinder(binder())
        .register(RaindropCommands.class);

    final PermissionBinder permissions = new PermissionBinder(binder());
    for(int i = RaindropConstants.MULTIPLIER_MAX; i > 0; i = i - RaindropConstants.MULTIPLIER_INCREMENT) {
        permissions.bindPermission().toInstance(new Permission("raindrops.multiplier." + i, PermissionDefault.FALSE));
    }
}

private boolean updatePermission(String name, Map<String, Boolean> before, Map<String, Boolean> after) {
    if(Objects.equals(before, after)) return false;

    final Permission perm = new Permission(name, PermissionDefault.FALSE, after);
    pluginManager.removePermission(perm);
    pluginManager.addPermission(perm);
    return true;
}

public Message broadcast(Permission permission) {
    for (Player player : Bukkit.getOnlinePlayers()) {
        if (player.hasPermission(permission)) {
            this.send(player);
        }
    }
    Bukkit.getConsoleSender().sendMessage(inner.toLegacyText());
    Bukkit.getConsoleSender().sendMessage("broadcast to players with permission:" + permission);
    return this;
}

public SimpleFilteredChannel(String format, Permission permission, double scoreThreshold, float partial) {
    super(format, permission);

    Preconditions.checkArgument(scoreThreshold > 0, "Score threshold must be greater than 0!");
    this.scoreThreshold = scoreThreshold;
    this.partial = partial;

    this.chatModerator = (ChatModeratorPlugin) Bukkit.getPluginManager().getPlugin("ChatModerator");
}

@Override
public List<Permission> getPerms() {
    List<Permission> p = new ArrayList<Permission>();

    p.add(new Permission("minecraft.command.stop"));

    return p;
}

@Override
public List<String> onTabComplete(CommandSender sender, Command command, String label, String[] args) {
    List<String> auto = new ArrayList<String>();

    if (command != this.command)
        return auto;

    for (Permission p : options.keySet()) {
        if (p == null || sender.hasPermission(p)) {
            //auto.add(String.join(" ", options.get(p)));
            for (int i = 0; i < options.get(p).length; i++) {
                String s = options.get(p)[i];
                /*if (((args.length == 0 && i == 0) || (args.length - 1 == i && s.startsWith(args[i]))) && !auto.contains(options.get(p)[0])) {
                    //if (options.get(p).length > i + 1 && !auto.contains(options.get(p)[i + 1])) {
                        auto.add(options.get(p)[i]);
                    //}
                }/* else if (args.length == 0 && !auto.contains(options.get(p)[0])) {
                    auto.add(options.get(p)[0]);
                }*/
                if (args.length != 0 && args.length == i && !auto.contains(options.get(p)[0]) && options.get(p)[i - 1].equalsIgnoreCase(args[i - 1])) {
                    auto.add(options.get(p)[i]);
                } else if (args.length == 0 && i == 0 && !auto.contains(options.get(p)[0])) {
                    auto.add(options.get(p)[i]);
                }
            }
        }
    }

    return auto;
}

@Override
public boolean hasPermission(Permission perm) {
    if (!Sponge.isServerAvailable()) return false;
    if(!(getSpongeEntity() instanceof Player)) return false;
    Optional<Player> optionalP = Sponge.getServer().getPlayer(this.getUniqueId());
    return optionalP.map(p -> hasPermission(perm.getName())).orElse(false);
}

public void setup() {
    ImmutableMap.Builder<Map.Entry<String, Boolean>, ImmutableMap<String, Boolean>> permissions = ImmutableMap.builder();

    // iterate all permissions registered on the platform & resolve.
    for (Permission permission : Bukkit.getServer().getPluginManager().getPermissions()) {
        resolve(permissions, permission, true);
        resolve(permissions, permission, false);
    }

    this.permissions = permissions.build();
}

private static void calculateDefaults(Map<String, Boolean> map, DummyPermissible p, boolean op) {
    pm().subscribeToDefaultPerms(op, p);

    Set<Permission> defaults = pm().getDefaultPermissions(op);
    for (Permission perm : defaults) {
        String name = perm.getName().toLowerCase();

        map.put(name, true);
        pm().subscribeToPermission(name, p);

        // register defaults for any children too
        calculateChildPermissions(map, p, perm.getChildren(), false);
    }
}

@Override
public boolean hasPermission(String permission) {
    if (permission == null) {
        throw new NullPointerException("permission");
    }

    Tristate ts = this.user.getCachedData().getPermissionData(calculateContexts()).getPermissionValue(permission, CheckOrigin.PLATFORM_PERMISSION_CHECK);
    return ts != Tristate.UNDEFINED ? ts.asBoolean() : Permission.DEFAULT_PERMISSION.getValue(isOp());
}

@Override
public boolean hasPermission(Permission permission) {
    if (permission == null) {
        throw new NullPointerException("permission");
    }

    final boolean result = this.delegate.hasPermission(permission);
    logCheck(CheckOrigin.PLATFORM_PERMISSION_CHECK, permission.getName(), result);
    return result;
}

private void calculatePermissionDefault(Permission perm) {
    if ((perm.getDefault() == PermissionDefault.OP) || (perm.getDefault() == PermissionDefault.TRUE)) {
        defaultPerms.get(true).add(perm);
        dirtyPermissibles(true);
    }
    if ((perm.getDefault() == PermissionDefault.NOT_OP) || (perm.getDefault() == PermissionDefault.TRUE)) {
        defaultPerms.get(false).add(perm);
        dirtyPermissibles(false);
    }
}

@Override
public final boolean onCommand(final CommandSender sender, final Command command, final String label, String[] args) {
    if(!sender.hasPermission("owngarden.command")) {
        OwnGarden.log(ChatColor.RED, "You do not have the permission to execute this command.", sender);
        return true;
    }

    final PluginDescriptionFile description = Bukkit.getPluginManager().getPlugin("OwnGarden").getDescription();
    sender.sendMessage(ChatColor.GREEN + description.getName() + " v" + description.getVersion() + ChatColor.GOLD + " by " + Joiner.on(' ').join(description.getAuthors()));

    final StringBuilder builder = new StringBuilder();
    for(int i = 0; i != ChatPaginator.GUARANTEED_NO_WRAP_CHAT_PAGE_WIDTH - 2; i++) {
        builder.append("=");
    }
    final String line = builder.toString();
    sender.sendMessage(ChatColor.RESET + line);

    sender.sendMessage(ChatColor.GOLD + "SCHEMATICS : ");

    sender.sendMessage(ChatColor.RESET + "" + ChatColor.BOLD + "- Oak : " + ChatColor.RESET + Joiner.on(' ').join(OwnGarden.config.saplingOakSchematics));
    sender.sendMessage(ChatColor.BOLD + "- Spruce : " + ChatColor.RESET + Joiner.on(' ').join(OwnGarden.config.saplingSpruceSchematics));
    sender.sendMessage(ChatColor.BOLD + "- Jungle : " + ChatColor.RESET + Joiner.on(' ').join(OwnGarden.config.saplingJungleSchematics));
    sender.sendMessage(ChatColor.BOLD + "- Acacia : " + ChatColor.RESET + Joiner.on(' ').join(OwnGarden.config.saplingAcaciaSchematics));
    sender.sendMessage(ChatColor.BOLD + "- Dark Oak : " + ChatColor.RESET + Joiner.on(' ').join(OwnGarden.config.saplingDarkOakSchematics));

    sender.sendMessage(line);
    sender.sendMessage(ChatColor.GOLD + "PERMISSIONS : ");

    for(final Permission permission : description.getPermissions()) {
        sender.sendMessage(sender.hasPermission(permission) ?
                (ChatColor.GREEN + "- You have the permission " + ChatColor.BOLD + permission.getName() + ChatColor.RESET + ChatColor.GREEN + ".") :
                (ChatColor.RED + "- You do not have the permission " + ChatColor.BOLD + permission.getName() + ChatColor.RESET + ChatColor.RED + ".")
        );
    }

    sender.sendMessage(ChatColor.RESET + line);
    sender.sendMessage(ChatColor.AQUA + "" + ChatColor.ITALIC + "The above list is scrollable.");
    return true;
}

private static String toNukkitPermissionDefault(PermissionDefault permissionDefault) {
    switch (permissionDefault) {
    case FALSE:
        return cn.nukkit.permission.Permission.DEFAULT_FALSE;
    case NOT_OP:
        return cn.nukkit.permission.Permission.DEFAULT_NOT_OP;
    case OP:
        return cn.nukkit.permission.Permission.DEFAULT_OP;
    case TRUE:
        return cn.nukkit.permission.Permission.DEFAULT_TRUE;
    default:
        throw new UnsupportedOperationException("Unknown permission default: " + permissionDefault);
    }
}

@EventHandler
public void onJoin(PlayerMoveEvent e)
{
    if(!tl.contains(e.getPlayer()))
    {
        if(e.getPlayer().hasPermission(new Permission("bag.resource",PermissionDefault.TRUE)) && Bags.cfg.getBoolean("resourcepack-enabled"))
        {
            Util.sendRequest(e.getPlayer());
        }
    }

    tl.add(e.getPlayer());
}

/**
 * @return zero or positive: give that much money to player
 * -1: not enough item in hand
 * -2: item not match
 */
public double purchase(Player p, int amount) {
    ItemStack itemHand = p.getInventory().getItemInMainHand();
    if (itemHand.getAmount() < amount) return -1;
    if (!templateItem.matchRule.matches(itemHand)) return -2;
    if (amountRemains < amount && amountRemains >= 0) amount = amountRemains;
    int new_amount = itemHand.getAmount() - amount;
    if (new_amount == 0) {
        p.getInventory().setItemInMainHand(new ItemStack(Material.AIR));
    } else {
        itemHand.setAmount(new_amount);
    }

    if (owner != null) {
        ItemStack tmp = itemHand.clone();
        tmp.setAmount(amount);
        Utils.giveItem(owner, tmp);
    }

    if (amountRemains >= 0) amountRemains -= amount;
    soldAmount += amount;
    new Message(I18n.format("user.req.sold_amount_0", p.getName(), amount))
            .append("{itemName}", templateItem.itemTemplate)
            .appendFormat(plugin.i18n, "user.req.sold_amount_1", amountRemains)
            .broadcast();
    logger.info(I18n.format("log.info.req_sell", uid(this), amount, amountRemains, p.getName()));
    if (amountRemains == 0) {
        new Message(I18n.format("user.req.sold_out")).broadcast(new Permission("heh.bid"));
        halt();
        logger.info(I18n.format("log.info.req_finish", uid(this), soldAmount, "SOLD_OUT"));
        finishCallback.run();
    }
    return unitPrice * amount;
}

@Override
public void run() {
    finishCallback.run();
    if (owner != null && amountRemains > 0) {
        plugin.eco.deposit(owner, amountRemains * unitPrice);
        amountRemains = 0;
        plugin.reqManager.cooldown.put(owner.getUniqueId(), System.currentTimeMillis() + (plugin.config.playerRequisitionCooldownTicks * 50));
    }
    new Message(I18n.format("user.req.finish")).broadcast(new Permission("heh.bid"));
    logger.info(I18n.format("log.info.req_finish", uid(RequisitionInstance.this), soldAmount, "TIMEOUT"));
    if (owner == null && plugin.systemBalance.isEnabled()) {
        plugin.logger.info(I18n.format("log.info.current_balance", plugin.systemBalance.getBalance()));
        plugin.config.save();
    }
}

public void halt() {
    if (currentAuction != null) {
        currentAuction.halt();
        currentAuction = null;
        new Message(I18n.format("user.auc.halted")).broadcast(new Permission("heh.bid"));
    }
}

@Override
public void run() {
    switch (stage) {
        case 0:
            if (currentHighPrice >= 0)
                new Message(I18n.format("user.auc.first", currentHighPrice)).broadcast(new Permission("heh.bid"));
            stage = 1;
            checkPointListener = new CheckPointListener();
            checkPointListener.runTaskLater(plugin, timeout);
            break;
        case 1:
            if (currentHighPrice >= 0)
                new Message(I18n.format("user.auc.second", currentHighPrice)).broadcast(new Permission("heh.bid"));
            stage = 2;
            checkPointListener = new CheckPointListener();
            checkPointListener.runTaskLater(plugin, timeout);
            break;
        case 2:
            if (currentHighPrice >= 0)
                new Message(I18n.format("user.auc.third", currentHighPrice)).broadcast(new Permission("heh.bid"));
            finish();

            stage = 3;
            break;
        case 3:
            // BukkitRunnable sucks again
            checkPointListener.cancel();
            checkPointListener = null;
            break;
    }
}

@Override
public Permission getPermission(String name) {
    cn.nukkit.permission.Permission nukkitPermission = nukkit.getPermission(name);
    if (nukkitPermission == null) {
        return null;
    }
    return PokkitPermission.toBukkit(nukkitPermission);
}

public SimplePluginManager(Server instance, SimpleCommandMap commandMap) {
    server = instance;
    this.commandMap = commandMap;

    defaultPerms.put(true, new HashSet<Permission>());
    defaultPerms.put(false, new HashSet<Permission>());
}

public void addPermission(Permission perm) {
    String name = perm.getName().toLowerCase();

    if (permissions.containsKey(name)) {
        throw new IllegalArgumentException("The permission " + name + " is already defined!");
    }

    permissions.put(name, perm);
    calculatePermissionDefault(perm);
}

private static Permission registerWhitelist(Permission parent) {
    Permission whitelist = DefaultPermissions.registerPermission(PREFIX + "whitelist", "Allows the user to modify the server whitelist", PermissionDefault.OP, parent);

    DefaultPermissions.registerPermission(PREFIX + "whitelist.add", "Allows the user to add a player to the server whitelist", whitelist);
    DefaultPermissions.registerPermission(PREFIX + "whitelist.remove", "Allows the user to remove a player from the server whitelist", whitelist);
    DefaultPermissions.registerPermission(PREFIX + "whitelist.reload", "Allows the user to reload the server whitelist", whitelist);
    DefaultPermissions.registerPermission(PREFIX + "whitelist.enable", "Allows the user to enable the server whitelist", whitelist);
    DefaultPermissions.registerPermission(PREFIX + "whitelist.disable", "Allows the user to disable the server whitelist", whitelist);
    DefaultPermissions.registerPermission(PREFIX + "whitelist.list", "Allows the user to list all the users on the server whitelist", whitelist);

    whitelist.recalculatePermissibles();

    return whitelist;
}