/* * PlayerVaultsX * Copyright (C) 2013 Trent Hensler * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ package com.drtshock.playervaults.vaultmanagement; import com.drtshock.playervaults.PlayerVaults; import com.drtshock.playervaults.translations.Lang; import org.bukkit.Bukkit; import org.bukkit.OfflinePlayer; import org.bukkit.command.CommandSender; import org.bukkit.configuration.ConfigurationSection; import org.bukkit.configuration.file.YamlConfiguration; import org.bukkit.entity.Player; import org.bukkit.inventory.Inventory; import org.bukkit.scheduler.BukkitRunnable; import java.io.File; import java.io.IOException; import java.util.ArrayList; import java.util.List; import java.util.Map; import java.util.UUID; import java.util.concurrent.ConcurrentHashMap; import java.util.logging.Level; /** * Class to handle vault operations with new UUIDs. */ @Deprecated public class UUIDVaultManager { private static UUIDVaultManager instance; private final File directory = PlayerVaults.getInstance().getUuidData(); private final Map<String, YamlConfiguration> cachedVaultFiles = new ConcurrentHashMap<>(); public UUIDVaultManager() { instance = this; } /** * Get the instance of this class. * * @return - instance of this class. */ public static UUIDVaultManager getInstance() { return instance; } /** * Saves the inventory to the specified player and vault number. * * @param inventory The inventory to be saved. * @param target The player of whose file to save to. * @param number The vault number. */ public void saveVault(Inventory inventory, String target, int number) { int size = inventory.getSize(); YamlConfiguration yaml = getPlayerVaultFile(target); if (size == 54) { yaml.set("vault" + number, null); } else { for (int x = 0; x < size; x++) { yaml.set("vault" + number + "." + x, null); } } List<String> list = Serialization.toString(inventory); String[] ser = list.toArray(new String[0]); for (int x = 0; x < ser.length; x++) { if (!ser[x].equalsIgnoreCase("null")) { yaml.set("vault" + number + "." + x, ser[x]); } } saveFileSync(target, yaml); } /** * Load the player's vault and return it. * * @param player The holder of the vault. * @param number The vault number. */ public Inventory loadOwnVault(Player player, int number, int size) { if (size % 9 != 0) { size = PlayerVaults.getInstance().getDefaultVaultSize(); } String title = Lang.VAULT_TITLE.toString().replace("%number", String.valueOf(number)).replace("%p", player.getName()); VaultViewInfo info = new VaultViewInfo(player.getUniqueId().toString(), number); Inventory inv; if (PlayerVaults.getInstance().getOpenInventories().containsKey(info.toString())) { inv = PlayerVaults.getInstance().getOpenInventories().get(info.toString()); } else { YamlConfiguration playerFile = getPlayerVaultFile(player.getUniqueId()); if (playerFile.getConfigurationSection("vault" + number) == null) { VaultHolder vaultHolder = new VaultHolder(number); if (EconomyOperations.payToCreate(player)) { inv = Bukkit.createInventory(vaultHolder, size, title); vaultHolder.setInventory(inv); } else { player.sendMessage(Lang.TITLE.toString() + Lang.INSUFFICIENT_FUNDS.toString()); return null; } } else { Inventory i = getInventory(playerFile, size, number, title); if (i == null) { return null; } else { inv = i; } } PlayerVaults.getInstance().getOpenInventories().put(info.toString(), inv); } return inv; } /** * Load the player's vault and return it. * * @param holder The holder of the vault. * @param number The vault number. */ public Inventory loadOtherVault(String holder, int number, int size) { if (size % 9 != 0) { size = PlayerVaults.getInstance().getDefaultVaultSize(); } String title = Lang.VAULT_TITLE.toString().replace("%number", String.valueOf(number)).replace("%p", PlayerVaults.getInstance().getNameIfPlayer(holder)); VaultViewInfo info = new VaultViewInfo(holder, number); Inventory inv; if (PlayerVaults.getInstance().getOpenInventories().containsKey(info.toString())) { inv = PlayerVaults.getInstance().getOpenInventories().get(info.toString()); } else { YamlConfiguration playerFile = getPlayerVaultFile(holder); Inventory i = getInventory(playerFile, size, number, title); if (i == null) { return null; } else { inv = i; } PlayerVaults.getInstance().getOpenInventories().put(info.toString(), inv); } return inv; } /** * Get an inventory from file. Returns null if the inventory doesn't exist. SHOULD ONLY BE USED INTERNALLY * * @param playerFile the YamlConfiguration file. * @param size the size of the vault. * @param number the vault number. * @return inventory if exists, otherwise null. */ private Inventory getInventory(YamlConfiguration playerFile, int size, int number, String title) { List<String> data = new ArrayList<>(); for (int x = 0; x < size; x++) { String line = playerFile.getString("vault" + number + "." + x); if (line != null) { data.add(line); } else { data.add("null"); } } return Serialization.toInventory(data, number, size, title); } /** * Gets an inventory without storing references to it. Used for dropping a players inventories on death. * * @param holder The holder of the vault. * @param number The vault number. * @return The inventory of the specified holder and vault number. */ public Inventory getVault(UUID holder, int number) { YamlConfiguration playerFile = getPlayerVaultFile(holder); ConfigurationSection section = playerFile.getConfigurationSection("vault" + number); int maxSize = VaultOperations.getMaxVaultSize(holder.toString()); String title = Lang.VAULT_TITLE.toString().replace("%number", String.valueOf(number)); if (section == null) { VaultHolder vaultHolder = new VaultHolder(number); Inventory inv = Bukkit.createInventory(vaultHolder, maxSize, title); vaultHolder.setInventory(inv); return inv; } else { List<String> data = new ArrayList<>(); for (String s : section.getKeys(false)) { String value = section.getString(s); data.add(value); } return Serialization.toInventory(data, number, maxSize, title); } } /** * Checks if a vault exists. * * @param holder holder of the vault. * @param number vault number. * @return true if the vault file and vault number exist in that file, otherwise false. */ public boolean vaultExists(String holder, int number) { File file = new File(directory, holder + ".yml"); if (!file.exists()) { return false; } return getPlayerVaultFile(holder).contains("vault" + number); } /** * Deletes a players vault. * * @param sender The sender of whom to send messages to. * @param holder The vault holder. * @param number The vault number. * @throws IOException Uh oh! */ public void deleteVault(CommandSender sender, final String holder, final int number) throws IOException { new BukkitRunnable() { @Override public void run() { File file = new File(directory, holder + ".yml"); if (!file.exists()) { return; } YamlConfiguration playerFile = YamlConfiguration.loadConfiguration(file); if (file.exists()) { playerFile.set("vault" + number, null); if (cachedVaultFiles.containsKey(holder)) { cachedVaultFiles.put(holder, playerFile); } try { playerFile.save(file); } catch (IOException ignored) { } } } }.runTaskAsynchronously(PlayerVaults.getInstance()); OfflinePlayer player = Bukkit.getPlayer(holder); if (player != null) { if (sender.getName().equalsIgnoreCase(player.getName())) { sender.sendMessage(Lang.TITLE.toString() + Lang.DELETE_VAULT.toString().replace("%v", String.valueOf(number))); } else { sender.sendMessage(Lang.TITLE.toString() + Lang.DELETE_OTHER_VAULT.toString().replace("%v", String.valueOf(number)).replaceAll("%p", player.getName())); } } String uuid = sender instanceof Player ? ((Player) sender).getUniqueId().toString() : holder; PlayerVaults.getInstance().getOpenInventories().remove(new VaultViewInfo(holder, number).toString()); } // Should only be run asynchronously public void cachePlayerVaultFile(String holder) { YamlConfiguration config = this.loadPlayerVaultFile(holder, false); if (config != null) { this.cachedVaultFiles.put(holder, config); } } public void removeCachedPlayerVaultFile(String holder) { cachedVaultFiles.remove(holder); } /** * Use below method for getting it via String. */ @Deprecated public YamlConfiguration getPlayerVaultFile(UUID holder) { return getPlayerVaultFile(holder.toString()); } /** * Get the holder's vault file. Create if doesn't exist. * * @param holder The vault holder. * @return The holder's vault config file. */ public YamlConfiguration getPlayerVaultFile(String holder) { if (cachedVaultFiles.containsKey(holder)) { return cachedVaultFiles.get(holder); } return loadPlayerVaultFile(holder); } public YamlConfiguration loadPlayerVaultFile(String holder) { return this.loadPlayerVaultFile(holder, true); } public YamlConfiguration loadPlayerVaultFile(String uniqueId, boolean createIfNotFound) { if (!this.directory.exists()) { this.directory.mkdir(); } File file = new File(this.directory, uniqueId + ".yml"); if (!file.exists()) { if (createIfNotFound) { try { file.createNewFile(); } catch (IOException e) { // Who cares? } } else { return null; } } return YamlConfiguration.loadConfiguration(file); } public void saveFileSync(final String holder, final YamlConfiguration yaml) { if (cachedVaultFiles.containsKey(holder)) { cachedVaultFiles.put(holder, yaml); } final boolean backups = PlayerVaults.getInstance().isBackupsEnabled(); final File backupsFolder = PlayerVaults.getInstance().getBackupsFolder(); final File file = new File(directory, holder + ".yml"); if (file.exists() && backups) { file.renameTo(new File(backupsFolder, holder + ".yml")); } try { yaml.save(file); } catch (IOException e) { PlayerVaults.getInstance().getLogger().log(Level.SEVERE, "Failed to save vault file for: " + holder, e); } } }