Accept Strings as inputs instead of UUIDs.

This leaves options for other plugins to hook into us to use our vault operations. I did a first shot of this with FactionsUUID.
* This needs to be tested more in depth before being pushed to a release version as it changes how we handle a lot of our dupe checks.

pom.xml

@@ -4,9 +4,9 @@
 
     <groupId>com.drtshock</groupId>
     <artifactId>PlayerVaults</artifactId>
-    <version>3.5.8-SNAPSHOT</version>
+    <version>3.6.0-SNAPSHOT</version>
     <name>PlayerVaults</name>
-    <url>http://dev.bukkit.org/bukkit-plugins/playervaults/</url>
+    <url>http://dev.bukkit.org/pancakes/playervaults/</url>
 
     <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

src/main/java/com/drtshock/playervaults/PlayerVaults.java

@@ -34,6 +34,7 @@ import net.milkbowl.vault.economy.Economy;
 import org.bukkit.Bukkit;
 import org.bukkit.ChatColor;
 import org.bukkit.Material;
+import org.bukkit.OfflinePlayer;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandSender;
 import org.bukkit.configuration.file.YamlConfiguration;
@@ -51,6 +52,7 @@ import java.io.OutputStream;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Set;
+import java.util.UUID;
 import java.util.logging.Level;
 
 public class PlayerVaults extends JavaPlugin {
@@ -128,7 +130,7 @@ public class PlayerVaults extends JavaPlugin {
                 Inventory inventory = player.getOpenInventory().getTopInventory();
                 if (inventory.getViewers().size() == 1) {
                     VaultViewInfo info = this.inVault.get(player.getUniqueId().toString());
-                    UUIDVaultManager.getInstance().saveVault(inventory, player.getUniqueId(), info.getNumber(), false);
+                    UUIDVaultManager.getInstance().saveVault(inventory, player.getUniqueId().toString(), info.getNumber(), false);
                     this.openInventories.remove(info.toString());
                 }
 
@@ -375,6 +377,23 @@ public class PlayerVaults extends JavaPlugin {
         return this.backupsFolder;
     }
 
+    /**
+     * Tries to get a name from a given String that we hope is a UUID.
+     * @param potentialUUID - potential UUID to try to get the name for.
+     * @return the player's name if we can find it, otherwise return what got passed to us.
+     */
+    public String getNameIfPlayer(String potentialUUID) {
+        UUID uuid;
+        try {
+            uuid = UUID.fromString(potentialUUID);
+        } catch (Exception e) {
+            return potentialUUID;
+        }
+
+        OfflinePlayer offlinePlayer = Bukkit.getOfflinePlayer(uuid);
+        return offlinePlayer != null ? offlinePlayer.getName() : potentialUUID;
+    }
+
     public boolean isBlockedMaterial(Material mat) {
         return blockedMats.contains(mat);
     }

src/main/java/com/drtshock/playervaults/commands/VaultCommand.java

@@ -55,14 +55,12 @@ public class VaultCommand implements CommandExecutor {
                     }
                     break;
                 case 2:
-                    OfflinePlayer searchPlayer = Bukkit.getOfflinePlayer(args[0]);
+                    if(!player.hasPermission("playervaults.admin")) {
-                    if (searchPlayer == null || !searchPlayer.hasPlayedBefore()) {
+                        player.sendMessage(Lang.TITLE.toString() + Lang.NO_PERMS.toString());
-                        sender.sendMessage(Lang.TITLE.toString() + Lang.NO_PLAYER_FOUND.toString().replaceAll("%p", args[0]));
                         break;
                     }
-
+                    if (VaultOperations.openOtherVault(player, args[0], args[1])) {
-                    if (VaultOperations.openOtherVault(player, searchPlayer, args[1])) {
+                        PlayerVaults.getInstance().getInVault().put(player.getUniqueId().toString(), new VaultViewInfo(args[0], Integer.parseInt(args[1])));
-                        PlayerVaults.getInstance().getInVault().put(player.getUniqueId().toString(), new VaultViewInfo(searchPlayer.getUniqueId(), Integer.parseInt(args[1])));
                     }
                     break;
                 default:

src/main/java/com/drtshock/playervaults/converters/BackpackConverter.java

@@ -83,7 +83,7 @@ public class BackpackConverter implements Converter {
                             vault.setItem(Integer.parseInt(key.split(" ")[1]), item);
                         }
                         try {
-                            vaults.saveVault(vault, uuid, intoVaultNum);
+                            vaults.saveVault(vault, uuid.toString(), intoVaultNum);
                             converted++;
                         } catch (IOException e) {
                             plugin.getLogger().severe("Error converting Backpack: " + file.getName());

src/main/java/com/drtshock/playervaults/listeners/Listeners.java

@@ -43,7 +43,7 @@ import java.io.IOException;
 public class Listeners implements Listener {
 
     public final PlayerVaults plugin;
-    final UUIDVaultManager vm = UUIDVaultManager.getInstance();
+    private final UUIDVaultManager vaultManager = UUIDVaultManager.getInstance();
 
     public Listeners(PlayerVaults playerVaults) {
         this.plugin = playerVaults;
@@ -55,7 +55,8 @@ public class Listeners implements Listener {
             if (inv.getViewers().size() == 1) {
                 VaultViewInfo info = PlayerVaults.getInstance().getInVault().get(player.getUniqueId().toString());
                 try {
-                    vm.saveVault(inv, info.getHolderUUID(), info.getNumber());
+                    String target = info.getHolderUUID() != null ? info.getHolderUUID().toString() : info.getHolder();
+                    vaultManager.saveVault(inv, target, info.getNumber());
                 } catch (IOException e) {
                     // ignore
                 }

src/main/java/com/drtshock/playervaults/listeners/SignListener.java

@@ -100,7 +100,7 @@ public class SignListener implements Listener {
                                 return; // Otherwise it would try to add vault view info down there.
                             }
                         } else {
-                            Inventory inv = UUIDVaultManager.getInstance().loadOtherVault(offlinePlayer.getUniqueId(), num, VaultOperations.getMaxVaultSize(offlinePlayer));
+                            Inventory inv = UUIDVaultManager.getInstance().loadOtherVault(offlinePlayer.getUniqueId().toString(), num, VaultOperations.getMaxVaultSize(offlinePlayer));
                             if (inv == null) {
                                 player.sendMessage(Lang.TITLE.toString() + Lang.VAULT_DOES_NOT_EXIST.toString());
                             } else {

src/main/java/com/drtshock/playervaults/listeners/VaultPreloadListener.java

@@ -21,13 +21,13 @@ public class VaultPreloadListener implements Listener {
         new BukkitRunnable() {
             @Override
             public void run() {
-                vm.cachePlayerVaultFile(uuid);
+                vm.cachePlayerVaultFile(uuid.toString());
             }
         }.runTaskAsynchronously(PlayerVaults.getInstance());
     }
 
     @EventHandler(priority = EventPriority.MONITOR)
     public void onPlayerQuit(PlayerQuitEvent event) {
-        vm.removeCachedPlayerVaultFile(event.getPlayer().getUniqueId());
+        vm.removeCachedPlayerVaultFile(event.getPlayer().getUniqueId().toString());
     }
 }

src/main/java/com/drtshock/playervaults/vaultmanagement/EconomyOperations.java

@@ -47,7 +47,7 @@ public class EconomyOperations {
             return true;
         }
 
-        if (!UUIDVaultManager.getInstance().vaultExists(player.getUniqueId(), number)) {
+        if (!UUIDVaultManager.getInstance().vaultExists(player.getUniqueId().toString(), number)) {
             return payToCreate(player);
         } else {
             double cost = BUKKIT_CONFIG.getDouble("economy.cost-to-open", 10);

src/main/java/com/drtshock/playervaults/vaultmanagement/UUIDVaultManager.java

@@ -31,24 +31,24 @@ public class UUIDVaultManager {
     }
 
     private final File directory = PlayerVaults.getInstance().getVaultData();
-    private final Map<UUID, YamlConfiguration> cachedVaultFiles = new ConcurrentHashMap<>();
+    private final Map<String, YamlConfiguration> cachedVaultFiles = new ConcurrentHashMap<>();
 
     /**
      * Saves the inventory to the specified player and vault number.
      *
      * @param inventory The inventory to be saved.
-     * @param player    The player of whose file to save to.
+     * @param target    The player of whose file to save to.
      * @param number    The vault number.
      *
      * @throws java.io.IOException Uh oh!
      */
-    public void saveVault(Inventory inventory, UUID player, int number) throws IOException {
+    public void saveVault(Inventory inventory, String target, int number) throws IOException {
-        saveVault(inventory, player, number, true);
+        saveVault(inventory, target, number, true);
     }
 
-    public void saveVault(Inventory inventory, UUID player, int number, boolean async) {
+    public void saveVault(Inventory inventory, String target, int number, boolean async) {
         int size = inventory.getSize();
-        YamlConfiguration yaml = getPlayerVaultFile(player);
+        YamlConfiguration yaml = getPlayerVaultFile(target);
         if (size == 54) {
             yaml.set("vault" + number, null);
         } else {
@@ -64,9 +64,9 @@ public class UUIDVaultManager {
             }
         }
         if (async) {
-            saveFile(player, yaml);
+            saveFile(target, yaml);
         } else {
-            saveFileSync(player, yaml);
+            saveFileSync(target, yaml);
         }
     }
 
@@ -117,27 +117,23 @@ public class UUIDVaultManager {
      * @param holder The holder of the vault.
      * @param number The vault number.
      */
-    public Inventory loadOtherVault(UUID holder, int number, int size) {
+    public Inventory loadOtherVault(String holder, int number, int size) {
         if (size % 9 != 0) {
             size = 54;
         }
-        String title = Lang.VAULT_TITLE.toString().replace("%number", String.valueOf(number)).replace("%p", Bukkit.getOfflinePlayer(holder).getName());
+        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);
-            if (playerFile.getConfigurationSection("vault" + number) == null) {
-                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;
@@ -191,7 +187,7 @@ public class UUIDVaultManager {
         }
     }
 
-    public boolean vaultExists(UUID holder, int number) {
+    public boolean vaultExists(String holder, int number) {
         return getPlayerVaultFile(holder).contains("vault" + number);
     }
 
@@ -204,11 +200,11 @@ public class UUIDVaultManager {
      *
      * @throws IOException Uh oh!
      */
-    public void deleteVault(CommandSender sender, final UUID holder, final int number) throws IOException {
+    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.toString() + ".yml");
+                File file = new File(directory, holder + ".yml");
                 if (!file.exists()) {
                     return;
                 }
@@ -236,23 +232,31 @@ public class UUIDVaultManager {
             }
         }
 
-        PlayerVaults.getInstance().getOpenInventories().remove(new VaultViewInfo(holder.toString(), number).toString());
+        PlayerVaults.getInstance().getOpenInventories().remove(new VaultViewInfo(holder, number).toString());
     }
 
     // Should only be run asynchronously
-    public void cachePlayerVaultFile(UUID holder) {
+    public void cachePlayerVaultFile(String holder) {
         YamlConfiguration config = this.loadPlayerVaultFile(holder, false);
         if (config != null) {
             this.cachedVaultFiles.put(holder, config);
         }
     }
 
-    public void removeCachedPlayerVaultFile(UUID holder) {
+    public void removeCachedPlayerVaultFile(String holder) {
         if (cachedVaultFiles.containsKey(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.
      *
@@ -260,23 +264,23 @@ public class UUIDVaultManager {
      *
      * @return The holder's vault config file.
      */
-    public YamlConfiguration getPlayerVaultFile(UUID holder) {
+    public YamlConfiguration getPlayerVaultFile(String holder) {
         if (cachedVaultFiles.containsKey(holder)) {
             return cachedVaultFiles.get(holder);
         }
         return loadPlayerVaultFile(holder);
     }
 
-    public YamlConfiguration loadPlayerVaultFile(UUID holder) {
+    public YamlConfiguration loadPlayerVaultFile(String holder) {
         return this.loadPlayerVaultFile(holder, true);
     }
 
-    public YamlConfiguration loadPlayerVaultFile(UUID uniqueId, boolean createIfNotFound) {
+    public YamlConfiguration loadPlayerVaultFile(String uniqueId, boolean createIfNotFound) {
         if (!this.directory.exists()) {
             this.directory.mkdir();
         }
 
-        File file = new File(this.directory, uniqueId.toString() + ".yml");
+        File file = new File(this.directory, uniqueId + ".yml");
         if (!file.exists()) {
             if (createIfNotFound) {
                 try {
@@ -298,38 +302,38 @@ public class UUIDVaultManager {
      * @param holder The vault holder of whose file to save.
      * @param yaml   The config to save.
      */
-    public void saveFile(final UUID holder, final YamlConfiguration yaml) {
+    public void saveFile(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.toString() + ".yml");
+        final File file = new File(directory, holder + ".yml");
         new BukkitRunnable() {
             @Override
             public void run() {
                 if (file.exists() && backups) {
-                    file.renameTo(new File(backupsFolder, holder.toString() + ".yml"));
+                    file.renameTo(new File(backupsFolder, holder + ".yml"));
                 }
                 try {
                     yaml.save(file);
                 } catch (Exception e) {
-                    PlayerVaults.getInstance().getLogger().log(Level.SEVERE, "Failed to save vault file for: " + holder.toString());
+                    PlayerVaults.getInstance().getLogger().log(Level.SEVERE, "Failed to save vault file for: " + holder);
                     e.printStackTrace();
                 }
             }
         }.runTaskAsynchronously(PlayerVaults.getInstance());
     }
 
-    public void saveFileSync(final UUID holder, final YamlConfiguration yaml) {
+    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.toString() + ".yml");
+        final File file = new File(directory, holder + ".yml");
         if (file.exists() && backups) {
-            file.renameTo(new File(backupsFolder, holder.toString() + ".yml"));
+            file.renameTo(new File(backupsFolder, holder + ".yml"));
         }
         try {
             yaml.save(file);

src/main/java/com/drtshock/playervaults/vaultmanagement/VaultOperations.java

@@ -18,6 +18,7 @@ package com.drtshock.playervaults.vaultmanagement;
 
 import com.drtshock.playervaults.PlayerVaults;
 import com.drtshock.playervaults.util.Lang;
+import org.bukkit.Bukkit;
 import org.bukkit.ChatColor;
 import org.bukkit.OfflinePlayer;
 import org.bukkit.command.CommandSender;
@@ -26,6 +27,7 @@ import org.bukkit.inventory.Inventory;
 import org.bukkit.inventory.InventoryView;
 
 import java.io.IOException;
+import java.util.UUID;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 public class VaultOperations {
@@ -83,6 +85,24 @@ public class VaultOperations {
         return false;
     }
 
+    /**
+     * Get the max size vault a player is allowed to have.
+     *
+     * @param target that is having his permissions checked.
+     *
+     * @return max size as integer. If no max size is set then it will default to 54.
+     */
+    public static int getMaxVaultSize(String target) {
+        UUID uuid;
+        try {
+            uuid = UUID.fromString(target);
+        } catch (Exception e) {
+            return 54;
+        }
+
+        return getMaxVaultSize(Bukkit.getOfflinePlayer(uuid));
+    }
+
     /**
      * Get the max size vault a player is allowed to have.
      *
@@ -167,15 +187,10 @@ public class VaultOperations {
      *
      * @return Whether or not the player was allowed to open it.
      */
-    public static boolean openOtherVault(Player player, OfflinePlayer holder, String arg) {
+    public static boolean openOtherVault(Player player, String holder, String arg) {
         if (isLocked()) {
             return false;
         }
-        if (player.hasPermission("playervaults.admin")) {
-            if (!holder.hasPlayedBefore()) {
-                player.sendMessage(Lang.TITLE.toString() + Lang.VAULT_DOES_NOT_EXIST.toString());
-                return false;
-            }
         int number = 0;
         try {
             number = Integer.parseInt(arg);
@@ -186,17 +201,24 @@ public class VaultOperations {
         } catch (NumberFormatException nfe) {
             player.sendMessage(Lang.TITLE.toString() + ChatColor.RED + Lang.MUST_BE_NUMBER);
         }
-            Inventory inv = UUIDVaultManager.getInstance().loadOtherVault(holder.getUniqueId(), number, getMaxVaultSize(holder));
+
+        // TODO: Add back way to check for vault existing for players but not factions.
+        /*
+            if (!UUIDVaultManager.getInstance().vaultExists(holder, number)) {
+                player.sendMessage(Lang.TITLE.toString() + Lang.VAULT_DOES_NOT_EXIST.toString());
+                return false;
+            }
+            */
+
+        Inventory inv = UUIDVaultManager.getInstance().loadOtherVault(holder, number, getMaxVaultSize(holder));
         if (inv == null) {
             player.sendMessage(Lang.TITLE.toString() + Lang.VAULT_DOES_NOT_EXIST.toString());
         } else {
             player.openInventory(inv);
-                player.sendMessage(Lang.TITLE.toString() + Lang.OPEN_OTHER_VAULT.toString().replace("%v", arg).replace("%p", holder.getName()));
+            player.sendMessage(Lang.TITLE.toString() + Lang.OPEN_OTHER_VAULT.toString().replace("%v", arg).replace("%p", holder));
             return true;
         }
-        } else {
+
-            player.sendMessage(Lang.TITLE.toString() + Lang.NO_PERMS);
-        }
         return false;
     }
 
@@ -224,7 +246,7 @@ public class VaultOperations {
 
             try {
                 if (EconomyOperations.refundOnDelete(player, number)) {
-                    UUIDVaultManager.getInstance().deleteVault(player, player.getUniqueId(), number);
+                    UUIDVaultManager.getInstance().deleteVault(player, player.getUniqueId().toString(), number);
                 }
             } catch (IOException e) {
                 player.sendMessage(Lang.TITLE.toString() + Lang.DELETE_VAULT_ERROR);
@@ -259,7 +281,7 @@ public class VaultOperations {
                 }
 
                 try {
-                    UUIDVaultManager.getInstance().deleteVault(sender, holder.getUniqueId(), number);
+                    UUIDVaultManager.getInstance().deleteVault(sender, holder.getUniqueId().toString(), number);
                 } catch (IOException e) {
                     sender.sendMessage(Lang.TITLE.toString() + Lang.DELETE_VAULT_ERROR);
                 }

src/main/java/com/drtshock/playervaults/vaultmanagement/VaultViewInfo.java

@@ -30,7 +30,7 @@ public class VaultViewInfo {
     final int number;
 
     /**
-     * Make a VaultViewObject
+     * Make a VaultViewObject.
      *
      * @param s The holder of the vault.
      * @param i The vault number.