ninja.leaping.configurate.commented.CommentedConfigurationNode Java Examples

@Override
public CommandResult execute(CommandSource src, CommandContext args) throws CommandException {
    String ip;
    GameProfile profile = args.<GameProfile>getOne("player").get();

    if (UltimateCore.get().getUserService().getUser(profile).get().getUser().isOnline()) {
        Player p = UltimateCore.get().getUserService().getUser(profile).get().getUser().getPlayer().get();
        ip = p.getConnection().getAddress().getAddress().toString().replace("/", "");
    } else {
        PlayerDataFile config = new PlayerDataFile(profile.getUniqueId());
        CommentedConfigurationNode node = config.get();
        ip = node.getNode("lastip").getString();
    }

    Messages.send(src, "ban.command.ip.success", "%player%", profile.getName().orElse(""), "%ip%", ip);
    return CommandResult.success();
}
 

@Listener(order = Order.EARLY)
public void onJoin(ClientConnectionEvent.Join event) {
    Player p = event.getTargetEntity();

    //Player file
    PlayerDataFile config = new PlayerDataFile(event.getTargetEntity().getUniqueId());
    CommentedConfigurationNode node = config.get();
    node.getNode("lastconnect").setValue(System.currentTimeMillis());
    String ip = event.getTargetEntity().getConnection().getAddress().getAddress().toString().replace("/", "");
    node.getNode("lastip").setValue(ip);
    config.save(node);

    //Ipcache file
    GlobalDataFile file = new GlobalDataFile("ipcache");
    CommentedConfigurationNode node2 = file.get();
    node2.getNode(ip, "name").setValue(p.getName());
    node2.getNode(ip, "uuid").setValue(p.getUniqueId().toString());
    file.save(node2);
}
 

/**
     * This method completes a datafile.
     * Any fields that are in the asset provided but not in the datafile will be set in the datafile.
     *
     * @param file  The file to complete
     * @param asset The asset with the default values
     * @return Whether anything was added to the file
     */
    public static boolean complete(RawConfig file, Asset asset) {
        try {
            ConfigurationLoader<CommentedConfigurationNode> loader = HoconConfigurationLoader.builder().setURL(asset.getUrl()).build();
            CommentedConfigurationNode assetnode = loader.load();
            CommentedConfigurationNode sourcenode = file.get();

//            if (complete(assetnode, sourcenode)) {
//                file.save(assetnode);
//                return true;
//            }
            return false;
        } catch (Exception ex) {
            ErrorLogger.log(ex, "Config completion failed for " + file + " / " + asset);
            return false;
        }
    }
 

public static void addRule(String rule)
{
	CommentedConfigurationNode node = Configs.getConfig(rulesConfig).getNode("rules", "rules");
	String formattedItem = (rule + ",");

	if (configManager.getString(node).isPresent())
	{
		String items = node.getString();

		if (!items.contains(formattedItem))
			Configs.setValue(rulesConfig, node.getPath(), items + formattedItem);
		return;
	}

	Configs.setValue(rulesConfig, node.getPath(), formattedItem);
}
 

@Listener
public void onDrop(DropItemEvent.Dispense event) {

    ModuleConfig config = Modules.BLACKLIST.get().getConfig().get();
    CommentedConfigurationNode hnode = config.get();
    for (Entity en : event.getEntities()) {
        if (!(en instanceof Item)) continue;
        Item item = (Item) en;
        CommentedConfigurationNode node = hnode.getNode("items", item.getItemType().getId());
        if (!node.isVirtual()) {
            if (node.getNode("deny-drop").getBoolean()) {
                event.setCancelled(true);
            }
        }
    }
}
 

public void loadConfig(CommentedConfigurationNode node) throws IOException
{
    try
    {
        Path configDir = plugin.getConfigDir();
        Map<String, VirtualChestInventory> newOnes = new LinkedHashMap<>();
        this.menuDirs = ImmutableList.copyOf(node.getList(TypeToken.of(String.class), this::releaseExample));
        this.menuDirs.stream().map(configDir::resolve).forEach(p -> newOnes.putAll(this.scanDir(p.toFile())));
        this.updateInventories(newOnes);
        this.fireLoadEvent();
    }
    catch (ObjectMappingException e)
    {
        throw new IOException(e);
    }
}
 

public void saveConfig(CommentedConfigurationNode node)
{
    String databaseUrlComment = "virtualchest.config.recording.databaseUrl.comment";
    String rulesComment = "virtualchest.config.recording.filter.rules.comment";
    String modeComment = "virtualchest.config.recording.filter.mode.comment";
    String enabledComment = "virtualchest.config.recording.enabled.comment";
    String filterComment = "virtualchest.config.recording.filter.comment";
    String recordingComment = "virtualchest.config.recording.comment";
    if (this.databaseUrl.isEmpty())
    {
        this.translation.withComment(node.getNode("enabled"), enabledComment).setValue(false);
        this.translation.withComment(node, recordingComment);
    }
    else
    {
        this.translation.withComment(node.getNode("filter", "mode"), modeComment).setValue(this.filterMode.name().toLowerCase());
        this.translation.withComment(node.getNode("filter", "rules"), rulesComment).setValue(this.filterRuleList);
        this.translation.withComment(node.getNode("database-url"), databaseUrlComment).setValue(this.databaseUrl);
        this.translation.withComment(node.getNode("enabled"), enabledComment).setValue(true);
        this.translation.withComment(node.getNode("filter"), filterComment);
        this.translation.withComment(node, recordingComment);
    }
}
 

@Listener
public void onChange(ChangeInventoryEvent event, @First Player p) {
    ModuleConfig config = Modules.BLACKLIST.get().getConfig().get();
    CommentedConfigurationNode hnode = config.get();
    try {
        for (Inventory s : event.getTargetInventory().slots()) {
            ItemStack item = s.peek();
            CommentedConfigurationNode node = hnode.getNode("items", item.getType().getKey());
            if (!node.isVirtual()) {
                if (node.getNode("deny-possession").getBoolean()) {
                    s.poll();
                }
            }
        }
    } catch (Exception ignore) {
    }
}
 

@SuppressWarnings({"unchecked", "rawtypes"})
public void resetMessageData(String message) {
    for (Map.Entry<Object, ? extends CommentedConfigurationNode> mapEntry : this.root.getNode(GriefPreventionPlugin.MOD_ID).getChildrenMap().entrySet()) {
        CommentedConfigurationNode node = (CommentedConfigurationNode) mapEntry.getValue();
        String key = "";
        String comment = node.getComment().orElse(null);
        if (comment == null && node.getKey() instanceof String) {
            key = (String) node.getKey();
            if (key.equalsIgnoreCase(message)) {
                this.root.getNode(GriefPreventionPlugin.MOD_ID).removeChild(mapEntry.getKey());
            }
        }
    }
 
    try {
        this.loader.save(this.root);
        this.configMapper = (ObjectMapper.BoundInstance) ObjectMapper.forClass(MessageDataConfig.class).bindToNew();
        this.configBase = this.configMapper.populate(this.root.getNode(GriefPreventionPlugin.MOD_ID));
    } catch (IOException | ObjectMappingException e) {
        e.printStackTrace();
    }

   GriefPreventionPlugin.instance.messageData = this.configBase;
}
 

public static void removeLockedWeatherWorld(UUID worldUuid)
{
	CommentedConfigurationNode valueNode = Configs.getConfig(worldConfig).getNode("world", "weather", "locked");

	if (valueNode.getValue() != null)
	{
		if (valueNode.getString().contains(worldUuid.toString() + ", "))
		{
			Configs.setValue(worldConfig, valueNode.getPath(), valueNode.getString().replace(worldUuid.toString() + ", ", ""));
		}
		else
		{
			Configs.setValue(worldConfig, valueNode.getPath(), valueNode.getString().replace(worldUuid.toString(), ""));
		}
	}
}
 

/**
 * Get boolean {@link Optional} value for CommentedConfigurationNode if it is not null; Otherwise return Optional.empty.
 *
 * @param node The node for which the boolean value is needed
 * @return Optional.empty if null or Optional#of(Boolean) if not
 */
public Optional<Boolean> getBoolean(CommentedConfigurationNode node)
{
	if (checkNull(node))
		return Optional.empty();

	return Optional.of(node.getBoolean());
}
 

private <T> void setValueAndComment(ConfigurationNode node, TypeToken<T> type, T value, String comment)
        throws ObjectMappingException {
    node.setValue(type, value);
    if (node instanceof CommentedConfigurationNode) {
        ((CommentedConfigurationNode) node).setComment(comment);
    }
}
 

@Override
public void run() {
    CommentedConfigurationNode config = Modules.AFK.get().getConfig().get().get();
    for (Player player : Sponge.getServer().getOnlinePlayers()) {
        UltimateUser user = UltimateCore.get().getUserService().getUser(player);
        if (user.get(AfkKeys.IS_AFK).get()) {
            Text title = Messages.getFormatted("afk.title.title");
            Text subtitle;
            long timediff = (config.getNode("time", "kicktime").getInt() * 1000) - (System.currentTimeMillis() - user.get(AfkKeys.AFK_TIME).get());
            if (config.getNode("time", "kicktime").getInt() != -1 && timediff <= 0 && !player.hasPermission(AfkPermissions.UC_AFK_EXEMPT.get())) {
                player.kick(Messages.getFormatted("afk.kick.reason"));
            }
            if (player.hasPermission(AfkPermissions.UC_AFK_EXEMPT.get()) || config.getNode("time", "kicktime").getInt() == -1) {
                subtitle = Messages.getFormatted("afk.title.subtitle.exempt");
            } else if (config.getNode("title", "subtitle-show-seconds").getBoolean(true)) {
                subtitle = Messages.getFormatted("afk.title.subtitle.kick", "%time%", TimeUtil.format(timediff, 3, null));
            } else {
                subtitle = Messages.getFormatted("afk.title.subtitle.kick", "%time%", TimeUtil.format(timediff, 3, 11));
            }
            if (config.getNode("title", "subtitle").getBoolean(false) && (!player.hasPermission(AfkPermissions.UC_AFK_EXEMPT.get()) || config.getNode("title", "subtitle-exempt").getBoolean(false))) {
                //Show subtitle
                player.sendTitle(Title.builder().title(title).subtitle(subtitle).fadeIn(0).fadeOut(20).stay(config.getNode("title", "subtitle-refresh").getInt()).build());
            } else {
                //Don't show subtitle
                //TODO refresh?
                player.sendTitle(Title.builder().title(title).fadeIn(0).fadeOut(20).stay(config.getNode("title", "subtitle-refresh").getInt()).build());
            }
        }
    }
}
 

private boolean checkNull(CommentedConfigurationNode node)
{
	if (node.getValue() == null)
		return true;
	else
		return false;
}
 

/**
 * Get String {@link Optional} value for CommentedConfigurationNode if it is not null; Otherwise return Optional#empty.
 *
 * @param node The node for which the String value is needed
 * @return Optional#empty if null or Optional#of(String) if not
 */
public Optional<String> getString(CommentedConfigurationNode node)
{
	if (checkNull(node))
		return Optional.empty();

	return Optional.of(node.getString());
}
 

/**
 * Get long {@link Optional} value for CommentedConfigurationNode if it is not null; Otherwise return Optional#empty.
 *
 * @param node The node for which the long value is needed
 * @return Optional#empty if null or Optional#of(Long) if not
 */
public Optional<Long> getLong(CommentedConfigurationNode node)
{
	if (checkNull(node))
		return Optional.empty();

	return Optional.of(node.getLong());
}
 

/**
 * Get int {@link Optional} value for CommentedConfigurationNode if it is not null; Otherwise return Optional#empty.
 *
 * @param node The node for which the int value is needed
 * @return Optional#empty if null or Optional#of(Integer) if not
 */
public Optional<Integer> getInt(CommentedConfigurationNode node)
{
	if (checkNull(node))
		return Optional.empty();

	return Optional.of(node.getInt());
}
 

/**
 * Get float {@link Optional} value for CommentedConfigurationNode if it is not null; Otherwise return Optional#empty.
 *
 * @param node The node for which the float value is needed
 * @return Optional#empty if null or double value Optional#of(Float) if not
 */
public Optional<Float> getFloat(CommentedConfigurationNode node)
{
	if (checkNull(node))
		return Optional.empty();

	return Optional.of(node.getFloat());
}
 

/**
 * Get double {@link Optional} value for CommentedConfigurationNode if it is not null; Otherwise return Optional.empty.
 *
 * @param node The node for which the double value is needed
 * @return Optional.empty if null or Optional#of(Double) if not
 */
public Optional<Double> getDouble(CommentedConfigurationNode node)
{
	if (checkNull(node))
		return Optional.empty();

	return Optional.of(node.getDouble());
}
 

@Override
public void save(Game arg, List<Kit> kits) {
    ModuleConfig loader = Modules.KIT.get().getConfig().get();
    CommentedConfigurationNode node = loader.get();
    node.getNode("kits").getChildrenMap().keySet().forEach(node.getNode("kits")::removeChild);
    for (Kit kit : kits) {
        try {
            node.getNode("kits", kit.getId()).setValue(TypeToken.of(Kit.class), kit);
        } catch (ObjectMappingException e) {
            ErrorLogger.log(e, "Failed to save kits key");
        }
    }
    loader.save(node);
}
 

@SuppressWarnings("serial")
public Zone(UUID uuid, String name, Rect rect, UUID owner)
{
	this.uuid = uuid;
	this.name = name;
	this.owner = owner;
	this.coowners = new ArrayList<UUID>();
	this.rect = rect;
	

	this.flags = new Hashtable<String, Boolean>();
	for (Entry<Object, ? extends CommentedConfigurationNode> e : ConfigHandler.getNode("flags", "zones").getChildrenMap().entrySet())
	{
		flags.put(e.getKey().toString(), e.getValue().getBoolean());
	}
	this.perms = new Hashtable<String, Hashtable<String, Boolean>>()
	{{
		put(Nation.TYPE_OUTSIDER, new Hashtable<String, Boolean>()
		{{
			put(Nation.PERM_BUILD, ConfigHandler.getNode("zones", "perms").getNode(Nation.TYPE_OUTSIDER).getNode(Nation.PERM_BUILD).getBoolean());
			put(Nation.PERM_INTERACT, ConfigHandler.getNode("zones", "perms").getNode(Nation.TYPE_OUTSIDER).getNode(Nation.PERM_INTERACT).getBoolean());
		}});
		put(Nation.TYPE_CITIZEN, new Hashtable<String, Boolean>()
		{{
			put(Nation.PERM_BUILD, ConfigHandler.getNode("zones", "perms").getNode(Nation.TYPE_CITIZEN).getNode(Nation.PERM_BUILD).getBoolean());
			put(Nation.PERM_INTERACT, ConfigHandler.getNode("zones", "perms").getNode(Nation.TYPE_CITIZEN).getNode(Nation.PERM_INTERACT).getBoolean());
		}});
		put(Nation.TYPE_COOWNER, new Hashtable<String, Boolean>()
		{{
			put(Nation.PERM_BUILD, ConfigHandler.getNode("zones", "perms").getNode(Nation.TYPE_COOWNER).getNode(Nation.PERM_BUILD).getBoolean());
			put(Nation.PERM_INTERACT, ConfigHandler.getNode("zones", "perms").getNode(Nation.TYPE_COOWNER).getNode(Nation.PERM_INTERACT).getBoolean());
		}});
	}};
}
 

public static boolean useMySQL()
{
	CommentedConfigurationNode node = Configs.getConfig(mainConfig).getNode("mysql", "use");
	if (configManager.getBoolean(node).isPresent())
		return node.getBoolean();
	setUseMySQL(false);
	return false;
}
 

public static void ensurePositiveNumber(CommentedConfigurationNode node, Number def)
{
	if (!(node.getValue() instanceof Number) || node.getDouble(-1) < 0)
	{
		node.setValue(def);
	}
}
 

public static void ensureString(CommentedConfigurationNode node, String def)
{
	if (node.getString() == null)
	{
		node.setValue(def);
	}
}
 

public static boolean isWhitelisted(String type, String id) {
	if (id.equals("minecraft:air"))
		return true;
	if (!config.getNode("whitelist", type).hasListChildren())
		return false;
	for (CommentedConfigurationNode item : config.getNode("whitelist", type).getChildrenList()) {
		if (id.startsWith(item.getString())) {
			return true;
		}
	}
	return false;
}
 

public static CommentedConfigurationNode getNationRank(int numCitizens)
{
	CommentedConfigurationNode rank = config.getNode("nationRanks")
			.getChildrenList()
			.stream()
			.filter(node -> node.getNode("numCitizens").getInt() <= numCitizens)
			.max((CommentedConfigurationNode a, CommentedConfigurationNode b) ->
					Integer.compare(a.getNode("numCitizens").getInt(), b.getNode("numCitizens").getInt()))
			.get();
	return rank;
}
 

public static ConfigurationNode playerConfig(UUID uuid) {
    CommentedConfigurationNode settings = config.getNode("player-settings", uuid.toString());
    if (settings.isVirtual()) {
        settings.getNode("enabled").setValue(true);
    }
    return settings;
}
 

public static void loadConfig() {
    try {
        config = confLoader.load();
    } catch (IOException e) {
        logger.error("Error while loading config", e);
        config = confLoader.createEmptyNode();
    }
    CommentedConfigurationNode playerSettings = config.getNode("player-settings");
    if (playerSettings.isVirtual()) {
        playerSettings.setValue(Collections.emptyMap());
    }
}
 

public static PlayerSettings playerConfig(UUID uuid) {
    CommentedConfigurationNode settings = config.getNode("player-settings", uuid.toString());
    try {
        // Save defaults to config file
        dirty |= settings.isVirtual();
        return settingsMapper.bindToNew().populate(settings);
    } catch (ObjectMappingException e) {
        throw new RuntimeException(e);
    }
}
 

public static boolean unsafeEnchanmentsEnabled()
{
	CommentedConfigurationNode node = Configs.getConfig(mainConfig).getNode("unsafeenchantments", "enabled");
	if (configManager.getBoolean(node).isPresent())
		return node.getBoolean();
	setUnsafeEnchanmentsEnabled(false);
	return false;
}