Bump deps

pom.xml

@@ -4,7 +4,7 @@
 
     <groupId>com.drtshock</groupId>
     <artifactId>PlayerVaultsX</artifactId>
-    <version>4.2.11</version>
+    <version>4.2.14</version>
     <name>PlayerVaultsX</name>
     <url>https://www.spigotmc.org/resources/51204/</url>
 
@@ -101,7 +101,7 @@
         <dependency>
             <groupId>net.kyori</groupId>
             <artifactId>adventure-platform-bukkit</artifactId>
-            <version>4.1.2</version>
+            <version>4.3.0</version>
             <scope>compile</scope>
             <optional>true</optional>
             <exclusions>
@@ -118,7 +118,7 @@
         <dependency>
             <groupId>net.kyori</groupId>
             <artifactId>adventure-text-minimessage</artifactId>
-            <version>4.11.0</version>
+            <version>4.14.0</version>
             <scope>compile</scope>
             <optional>true</optional>
             <exclusions>
@@ -135,7 +135,7 @@
         <dependency>
             <groupId>com.google.code.gson</groupId>
             <artifactId>gson</artifactId>
-            <version>2.8.8</version>
+            <version>2.10.1</version>
             <scope>compile</scope>
         </dependency>
         <dependency>
@@ -153,7 +153,13 @@
         <dependency>
             <groupId>org.spigotmc</groupId>
             <artifactId>spigot-api</artifactId>
-            <version>1.13.1-R0.1-SNAPSHOT</version>
+            <version>1.14.4-R0.1-SNAPSHOT</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.googlecode.json-simple</groupId>
+            <artifactId>json-simple</artifactId>
+            <version>1.1.1</version>
             <scope>provided</scope>
         </dependency>
         <dependency>

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

@@ -50,6 +50,7 @@ import org.bukkit.configuration.InvalidConfigurationException;
 import org.bukkit.configuration.file.YamlConfiguration;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.meta.ItemMeta;
 import org.bukkit.plugin.Plugin;
 import org.bukkit.plugin.java.JavaPlugin;
 import org.bukkit.scheduler.BukkitRunnable;
@@ -94,6 +95,8 @@ public class PlayerVaults extends JavaPlugin {
     // VaultViewInfo - Inventory
     private final HashMap<String, Inventory> openInventories = new HashMap<>();
     private final Set<Material> blockedMats = new HashSet<>();
+    private boolean blockWithModelData = false;
+    private boolean blockWithoutModelData = false;
     private boolean useVault;
     private YamlConfiguration signs;
     private File signsFile;
@@ -292,8 +295,8 @@ public class PlayerVaults extends JavaPlugin {
                     String reply = new BufferedReader(new InputStreamReader(con.getInputStream(), StandardCharsets.UTF_8)).lines().collect(Collectors.joining("\n"));
                     Response response = new Gson().fromJson(reply, Response.class);
                     if (response.isSuccess()) {
-                        PlayerVaults.this.updateResponse = response;
                         if (response.isUpdateAvailable()) {
+                            PlayerVaults.this.updateResponse = response;
                             if (response.isUrgent()) {
                                 PlayerVaults.this.getServer().getOnlinePlayers().forEach(PlayerVaults.this::updateNotification);
                             }
@@ -393,8 +396,16 @@ public class PlayerVaults extends JavaPlugin {
 
         // Clear just in case this is a reload.
         blockedMats.clear();
+        this.blockWithModelData = false;
+        this.blockWithoutModelData = false;
         if (getConf().getItemBlocking().isEnabled()) {
             for (String s : getConf().getItemBlocking().getList()) {
+                if (s.equalsIgnoreCase("BLOCK_ALL_WITH_CUSTOM_MODEL_DATA")) {
+                    this.blockWithModelData = true;
+                }
+                if (s.equalsIgnoreCase("BLOCK_ALL_WITHOUT_CUSTOM_MODEL_DATA")) {
+                    this.blockWithoutModelData = true;
+                }
                 Material mat = Material.matchMaterial(s);
                 if (mat != null) {
                     blockedMats.add(mat);
@@ -402,6 +413,12 @@ public class PlayerVaults extends JavaPlugin {
                 }
             }
         }
+        try {
+            ItemMeta.class.getMethod("hasCustomModelData");
+        } catch (NoSuchMethodException e) {
+            this.blockWithModelData = false;
+            this.blockWithoutModelData = false;
+        }
 
         File lang = new File(this.getDataFolder(), "lang");
         if (lang.exists()) {
@@ -560,6 +577,14 @@ public class PlayerVaults extends JavaPlugin {
         return blockedMats.contains(mat);
     }
 
+    public boolean isBlockWithModelData() {
+        return this.blockWithModelData;
+    }
+
+    public boolean isBlockWithoutModelData() {
+        return this.blockWithoutModelData;
+    }
+
     /**
      * Tries to grab the server version as a string.
      *

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

@@ -19,10 +19,7 @@
 package com.drtshock.playervaults.commands;
 
 import com.drtshock.playervaults.PlayerVaults;
-import com.drtshock.playervaults.converters.BackpackConverter;
+import com.drtshock.playervaults.converters.*;
-import com.drtshock.playervaults.converters.Converter;
-import com.drtshock.playervaults.converters.Cosmic2Converter;
-import com.drtshock.playervaults.converters.Cosmic3Converter;
 import com.drtshock.playervaults.vaultmanagement.VaultOperations;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
@@ -40,6 +37,7 @@ public class ConvertCommand implements CommandExecutor {
         converters.add(new BackpackConverter());
         converters.add(new Cosmic2Converter());
         converters.add(new Cosmic3Converter());
+        converters.add(new EnderVaultsConverter());
         this.plugin = plugin;
     }
 

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

@@ -56,7 +56,7 @@ public class DeleteCommand implements CommandExecutor {
                 }
                 OfflinePlayer searchPlayer = Bukkit.getOfflinePlayer(args[0]);
                 String target = args[0];
-                if (searchPlayer != null && searchPlayer.hasPlayedBefore()) {
+                if (searchPlayer != null) {
                     target = searchPlayer.getUniqueId().toString();
                 }
 

src/main/java/com/drtshock/playervaults/config/file/Config.java

@@ -30,7 +30,10 @@ public class Config {
     public class Block {
         private boolean enabled = true;
         @Comment("Material list for blocked items (does not support ID's), only effective if the feature is enabled.\n" +
-                " If you don't know material names: https://hub.spigotmc.org/javadocs/bukkit/org/bukkit/Material.html")
+                " If you don't know material names: https://hub.spigotmc.org/javadocs/bukkit/org/bukkit/Material.html\n" +
+                "\n" +
+                "Also, if you add \"BLOCK_ALL_WITH_CUSTOM_MODEL_DATA\" or \"BLOCK_ALL_WITHOUT_CUSTOM_MODEL_DATA\"\n" +
+                " then either all items with custom model data will be blocked, or all items without custom model data will be blocked.")
         private List<String> list = new ArrayList<String>() {
             {
                 this.add("PUMPKIN");

src/main/java/com/drtshock/playervaults/config/file/Translation.java

@@ -174,6 +174,8 @@ public class Translation {
         private TL locked = TL.of("<error>Vaults are currently locked while conversion occurs. Please try again in a moment!");
         private TL help = TL.of("/pv <number>");
         private TL blockedItem = TL.of("<gold><item></gold> <error>is blocked from vaults.");
+        private TL blockedItemWithModelData = TL.of("<error>This item is blocked from vaults.");
+        private TL blockedItemWithoutModelData = TL.of("<error>This item is blocked from vaults.");
         private TL signsDisabled = TL.of("<error>Vault signs are currently disabled.");
         private TL blockedBadItem = TL.of("<error>This item is not allowed in a vault.");
     }
@@ -306,6 +308,14 @@ public class Translation {
         return this.translations.blockedItem;
     }
 
+    public @NonNull TL blockedItemWithModelData() {
+        return this.translations.blockedItemWithModelData;
+    }
+
+    public @NonNull TL blockedItemWithoutModelData() {
+        return this.translations.blockedItemWithoutModelData;
+    }
+
     public @NonNull TL signsDisabled() {
         return this.translations.signsDisabled;
     }

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

@@ -0,0 +1,127 @@
+/*
+ * PlayerVaultsX
+ * Copyright (C) 2013 Trent Hensler, turt2live
+ *
+ * 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.converters;
+
+import com.drtshock.playervaults.PlayerVaults;
+import com.drtshock.playervaults.vaultmanagement.VaultManager;
+import org.bukkit.command.CommandSender;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.plugin.Plugin;
+
+import java.io.IOException;
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.logging.Level;
+import java.util.stream.Stream;
+
+public class EnderVaultsConverter implements Converter {
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public int run(CommandSender initiator) {
+        PlayerVaults plugin = PlayerVaults.getInstance();
+        VaultManager vaultManager = VaultManager.getInstance();
+
+        Path path = plugin.getDataFolder().toPath().getParent().resolve("EnderVaults").resolve("data");
+        if (!Files.isDirectory(path)) {
+            plugin.getLogger().warning("Could not find EnderVaults data folder");
+            return -1;
+        }
+
+        MethodHandle load;
+        MethodHandle getInventory;
+        MethodHandle getMetadata;
+        Plugin enderVaultsPlugin = plugin.getServer().getPluginManager().getPlugin("EnderVaults");
+        Object dataStorage;
+
+        if (enderVaultsPlugin == null) {
+            plugin.getLogger().warning("EnderVaults not running. Need it to convert.");
+            return -1;
+        }
+        try {
+            Class<?> pluginClass = Class.forName("com.github.dig.endervaults.api.EnderVaultsPlugin");
+            Class<?> dataStorageClass = Class.forName("com.github.dig.endervaults.api.storage.DataStorage");
+            Class<?> bukkitVaultClass = Class.forName("com.github.dig.endervaults.bukkit.vault.BukkitVault");
+
+            MethodHandles.Lookup lookup = MethodHandles.publicLookup();
+
+            MethodType typeGetDataStorage = MethodType.methodType(dataStorageClass);
+            MethodHandle getDataStorage = lookup.findVirtual(pluginClass, "getDataStorage", typeGetDataStorage);
+
+            dataStorage = getDataStorage.invoke(enderVaultsPlugin);
+
+            MethodType typeLoad = MethodType.methodType(List.class, UUID.class);
+            load = lookup.findVirtual(dataStorageClass, "load", typeLoad);
+            MethodType typeGetInventory = MethodType.methodType(Inventory.class);
+            getInventory = lookup.findVirtual(bukkitVaultClass, "getInventory", typeGetInventory);
+            MethodType typeGetMetadata = MethodType.methodType(Map.class);
+            getMetadata = lookup.findVirtual(bukkitVaultClass, "getMetadata", typeGetMetadata);
+
+            if (!pluginClass.isAssignableFrom(enderVaultsPlugin.getClass())) {
+                plugin.getLogger().warning("EnderVaults plugin not of expected type");
+                return -1;
+            }
+        } catch (Throwable e) {
+            e.printStackTrace();
+            return -1;
+        }
+
+        AtomicInteger playerCount = new AtomicInteger(0);
+        try (Stream<Path> dir = Files.list(path)) {
+            dir.forEach(f -> {
+                if (!Files.isDirectory(f)) {
+                    return;
+                }
+                try {
+                    List<Object> list = (List<Object>) load.invoke(dataStorage, UUID.fromString(f.getFileName().toString()));
+                    for (Object vault : list) {
+                        Inventory inventory = (Inventory) getInventory.invoke(vault);
+                        Map<String, Object> meta = (Map<String, Object>) getMetadata.invoke(vault);
+                        Integer order = (Integer) meta.get("order");
+                        vaultManager.saveVault(inventory, f.getFileName().toString(), order);
+                    }
+                } catch (Throwable e) {
+                    e.printStackTrace();
+                    return;
+                }
+                playerCount.incrementAndGet();
+            });
+        } catch (IOException e) {
+            plugin.getLogger().log(Level.SEVERE, "Failed. ", e);
+        }
+        return playerCount.get();
+    }
+
+    @Override
+    public boolean canConvert() {
+        return Files.isDirectory(PlayerVaults.getInstance().getDataFolder().toPath().getParent().resolve("EnderVaults").resolve("data"));
+    }
+
+    @Override
+    public String getName() {
+        return "EnderVaults";
+    }
+}

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

@@ -135,10 +135,22 @@ public class Listeners implements Listener {
                         if (item == null) {
                             continue;
                         }
-                        if (!player.hasPermission("playervaults.bypassblockeditems") && PlayerVaults.getInstance().isBlockedMaterial(item.getType())) {
+                        if (!player.hasPermission("playervaults.bypassblockeditems")) {
-                            event.setCancelled(true);
+                            if (PlayerVaults.getInstance().isBlockWithModelData() && item.hasItemMeta() && item.getItemMeta().hasCustomModelData()) {
-                            this.plugin.getTL().blockedItem().title().with("item", item.getType().name()).send(player);
+                                event.setCancelled(true);
-                            return;
+                                this.plugin.getTL().blockedItemWithModelData().title().send(player);
+                                return;
+                            }
+                            if (PlayerVaults.getInstance().isBlockWithoutModelData() && (!item.hasItemMeta() || !item.getItemMeta().hasCustomModelData())) {
+                                event.setCancelled(true);
+                                this.plugin.getTL().blockedItemWithoutModelData().title().send(player);
+                                return;
+                            }
+                            if (PlayerVaults.getInstance().isBlockedMaterial(item.getType())) {
+                                event.setCancelled(true);
+                                this.plugin.getTL().blockedItem().title().with("item", item.getType().name()).send(player);
+                                return;
+                            }
                         }
                     }
                 }