summaryrefslogtreecommitdiffstats
path: root/Essentials2Compat/src/com
diff options
context:
space:
mode:
Diffstat (limited to 'Essentials2Compat/src/com')
-rw-r--r--Essentials2Compat/src/com/earth2me/essentials/Essentials.java22
-rw-r--r--Essentials2Compat/src/com/earth2me/essentials/EssentialsConf.java397
-rw-r--r--Essentials2Compat/src/com/earth2me/essentials/EssentialsUpgrade.java729
-rw-r--r--Essentials2Compat/src/com/earth2me/essentials/api/Economy.java231
4 files changed, 1379 insertions, 0 deletions
diff --git a/Essentials2Compat/src/com/earth2me/essentials/Essentials.java b/Essentials2Compat/src/com/earth2me/essentials/Essentials.java
new file mode 100644
index 000000000..dc612e8d6
--- /dev/null
+++ b/Essentials2Compat/src/com/earth2me/essentials/Essentials.java
@@ -0,0 +1,22 @@
+package com.earth2me.essentials;
+
+import org.bukkit.Bukkit;
+import org.bukkit.plugin.java.JavaPlugin;
+
+
+public class Essentials extends JavaPlugin
+{
+ @Override
+ public void onEnable()
+ {
+ Bukkit.getLogger().info("You can remove this compatibility plugin, when all plugins are updated to Essentials 3");
+ //TODO: Update files to new 3.0 format
+ //TODO: Move Eco Api here
+ }
+
+ @Override
+ public void onDisable()
+ {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+}
diff --git a/Essentials2Compat/src/com/earth2me/essentials/EssentialsConf.java b/Essentials2Compat/src/com/earth2me/essentials/EssentialsConf.java
new file mode 100644
index 000000000..0dc36e262
--- /dev/null
+++ b/Essentials2Compat/src/com/earth2me/essentials/EssentialsConf.java
@@ -0,0 +1,397 @@
+package com.earth2me.essentials;
+
+import static com.earth2me.essentials.I18n._;
+import com.google.common.io.Files;
+import java.io.*;
+import java.nio.ByteBuffer;
+import java.nio.CharBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.charset.Charset;
+import java.nio.charset.CharsetDecoder;
+import java.nio.charset.CoderResult;
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.Server;
+import org.bukkit.World;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.InvalidConfigurationException;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.inventory.ItemStack;
+
+
+@Deprecated
+public class EssentialsConf extends YamlConfiguration
+{
+ private static final Logger LOGGER = Logger.getLogger("Minecraft");
+ private transient File configFile;
+ private transient String templateName = null;
+ private transient Class<?> resourceClass = EssentialsConf.class;
+ private static final Charset UTF8 = Charset.forName("UTF-8");
+
+ public EssentialsConf(final File configFile)
+ {
+ super();
+ this.configFile = configFile;
+ }
+
+ public synchronized void load()
+ {
+ configFile = configFile.getAbsoluteFile();
+ if (!configFile.getParentFile().exists())
+ {
+ if (!configFile.getParentFile().mkdirs())
+ {
+ LOGGER.log(Level.SEVERE, _("failedToCreateConfig", configFile.toString()));
+ }
+ }
+ // This will delete files where the first character is 0. In most cases they are broken.
+ if (configFile.exists() && configFile.length() != 0)
+ {
+ try
+ {
+ final InputStream input = new FileInputStream(configFile);
+ try
+ {
+ if (input.read() == 0)
+ {
+ input.close();
+ configFile.delete();
+ }
+ }
+ catch (IOException ex)
+ {
+ LOGGER.log(Level.SEVERE, null, ex);
+ }
+ finally
+ {
+ try
+ {
+ input.close();
+ }
+ catch (IOException ex)
+ {
+ LOGGER.log(Level.SEVERE, null, ex);
+ }
+ }
+ }
+ catch (FileNotFoundException ex)
+ {
+ LOGGER.log(Level.SEVERE, null, ex);
+ }
+ }
+
+ if (!configFile.exists())
+ {
+ if (templateName != null)
+ {
+ LOGGER.log(Level.INFO, _("creatingConfigFromTemplate", configFile.toString()));
+ createFromTemplate();
+ }
+ else
+ {
+ try
+ {
+ LOGGER.log(Level.INFO, _("creatingEmptyConfig", configFile.toString()));
+ if (!configFile.createNewFile())
+ {
+ LOGGER.log(Level.SEVERE, _("failedToCreateConfig", configFile.toString()));
+ }
+ }
+ catch (IOException ex)
+ {
+ LOGGER.log(Level.SEVERE, _("failedToCreateConfig", configFile.toString()), ex);
+ }
+ }
+ }
+
+
+ try
+ {
+ final FileInputStream inputStream = new FileInputStream(configFile);
+ try
+ {
+ final FileChannel channel = inputStream.getChannel();
+ final ByteBuffer buffer = ByteBuffer.allocate((int)configFile.length());
+ channel.read(buffer);
+ buffer.rewind();
+ final CharBuffer data = CharBuffer.allocate((int)configFile.length());
+ CharsetDecoder decoder = UTF8.newDecoder();
+ CoderResult result = decoder.decode(buffer, data, true);
+ if (result.isError())
+ {
+ buffer.rewind();
+ data.clear();
+ LOGGER.log(Level.INFO, "File " + configFile.getAbsolutePath().toString() + " is not utf-8 encoded, trying " + Charset.defaultCharset().displayName());
+ decoder = Charset.defaultCharset().newDecoder();
+ result = decoder.decode(buffer, data, true);
+ if (result.isError())
+ {
+ throw new InvalidConfigurationException("Invalid Characters in file " + configFile.getAbsolutePath().toString());
+ }
+ else
+ {
+ decoder.flush(data);
+ }
+ }
+ else
+ {
+ decoder.flush(data);
+ }
+ final int end = data.position();
+ data.rewind();
+ super.loadFromString(data.subSequence(0, end).toString());
+ }
+ finally
+ {
+ inputStream.close();
+ }
+ }
+ catch (IOException ex)
+ {
+ LOGGER.log(Level.SEVERE, ex.getMessage(), ex);
+ }
+ catch (InvalidConfigurationException ex)
+ {
+ File broken = new File(configFile.getAbsolutePath() + ".broken." + System.currentTimeMillis());
+ configFile.renameTo(broken);
+ LOGGER.log(Level.SEVERE, "The file " + configFile.toString() + " is broken, it has been renamed to " + broken.toString(), ex.getCause());
+ }
+ }
+
+ private void createFromTemplate()
+ {
+ InputStream istr = null;
+ OutputStream ostr = null;
+ try
+ {
+ istr = resourceClass.getResourceAsStream(templateName);
+ if (istr == null)
+ {
+ LOGGER.log(Level.SEVERE, _("couldNotFindTemplate", templateName));
+ return;
+ }
+ ostr = new FileOutputStream(configFile);
+ byte[] buffer = new byte[1024];
+ int length = 0;
+ length = istr.read(buffer);
+ while (length > 0)
+ {
+ ostr.write(buffer, 0, length);
+ length = istr.read(buffer);
+ }
+ }
+ catch (IOException ex)
+ {
+ LOGGER.log(Level.SEVERE, _("failedToWriteConfig", configFile.toString()), ex);
+ }
+ finally
+ {
+ try
+ {
+ if (istr != null)
+ {
+ istr.close();
+ }
+ }
+ catch (IOException ex)
+ {
+ Logger.getLogger(EssentialsConf.class.getName()).log(Level.SEVERE, null, ex);
+ }
+ try
+ {
+ if (ostr != null)
+ {
+ ostr.close();
+ }
+ }
+ catch (IOException ex)
+ {
+ LOGGER.log(Level.SEVERE, _("failedToCloseConfig", configFile.toString()), ex);
+ }
+ }
+ }
+
+ public void setTemplateName(final String templateName)
+ {
+ this.templateName = templateName;
+ }
+
+ public File getFile()
+ {
+ return configFile;
+ }
+
+ public void setTemplateName(final String templateName, final Class<?> resClass)
+ {
+ this.templateName = templateName;
+ this.resourceClass = resClass;
+ }
+
+ public boolean hasProperty(final String path)
+ {
+ return isSet(path);
+ }
+
+ public Location getLocation(final String path, final Server server) throws Exception
+ {
+ final String worldName = getString((path == null ? "" : path + ".") + "world");
+ if (worldName == null || worldName.isEmpty())
+ {
+ return null;
+ }
+ final World world = server.getWorld(worldName);
+ if (world == null)
+ {
+ throw new Exception(_("invalidWorld"));
+ }
+ return new Location(world,
+ getDouble((path == null ? "" : path + ".") + "x", 0),
+ getDouble((path == null ? "" : path + ".") + "y", 0),
+ getDouble((path == null ? "" : path + ".") + "z", 0),
+ (float)getDouble((path == null ? "" : path + ".") + "yaw", 0),
+ (float)getDouble((path == null ? "" : path + ".") + "pitch", 0));
+ }
+
+ public void setProperty(final String path, final Location loc)
+ {
+ set((path == null ? "" : path + ".") + "world", loc.getWorld().getName());
+ set((path == null ? "" : path + ".") + "x", loc.getX());
+ set((path == null ? "" : path + ".") + "y", loc.getY());
+ set((path == null ? "" : path + ".") + "z", loc.getZ());
+ set((path == null ? "" : path + ".") + "yaw", loc.getYaw());
+ set((path == null ? "" : path + ".") + "pitch", loc.getPitch());
+ }
+
+ @Override
+ public ItemStack getItemStack(final String path)
+ {
+ final ItemStack stack = new ItemStack(
+ Material.valueOf(getString(path + ".type", "AIR")),
+ getInt(path + ".amount", 1),
+ (short)getInt(path + ".damage", 0));
+ final ConfigurationSection enchants = getConfigurationSection(path + ".enchant");
+ if (enchants != null)
+ {
+ for (String enchant : enchants.getKeys(false))
+ {
+ final Enchantment enchantment = Enchantment.getByName(enchant.toUpperCase(Locale.ENGLISH));
+ if (enchantment == null)
+ {
+ continue;
+ }
+ final int level = getInt(path + ".enchant." + enchant, enchantment.getStartLevel());
+ stack.addUnsafeEnchantment(enchantment, level);
+ }
+ }
+ return stack;
+ /*
+ * ,
+ * (byte)getInt(path + ".data", 0)
+ */
+ }
+
+ public void setProperty(final String path, final ItemStack stack)
+ {
+ final Map<String, Object> map = new HashMap<String, Object>();
+ map.put("type", stack.getType().toString());
+ map.put("amount", stack.getAmount());
+ map.put("damage", stack.getDurability());
+ Map<Enchantment, Integer> enchantments = stack.getEnchantments();
+ if (!enchantments.isEmpty())
+ {
+ Map<String, Integer> enchant = new HashMap<String, Integer>();
+ for (Map.Entry<Enchantment, Integer> entry : enchantments.entrySet())
+ {
+ enchant.put(entry.getKey().getName().toLowerCase(Locale.ENGLISH), entry.getValue());
+ }
+ map.put("enchant", enchant);
+ }
+ // getData().getData() is broken
+ //map.put("data", stack.getDurability());
+ set(path, map);
+ }
+
+ public long getLong(final String path, final long def)
+ {
+ try
+ {
+ final Number num = (Number)get(path);
+ return num == null ? def : num.longValue();
+ }
+ catch (ClassCastException ex)
+ {
+ return def;
+ }
+ }
+
+ @Override
+ public double getDouble(final String path, final double def)
+ {
+ try
+ {
+ Number num = (Number)get(path);
+ return num == null ? def : num.doubleValue();
+ }
+ catch (ClassCastException ex)
+ {
+ return def;
+ }
+ }
+
+ public void save()
+ {
+ try
+ {
+ save(configFile);
+ }
+ catch (IOException ex)
+ {
+ LOGGER.log(Level.SEVERE, ex.getMessage(), ex);
+ }
+ }
+
+ @Override
+ public synchronized void save(final File file) throws IOException
+ {
+ if (file == null)
+ {
+ throw new IllegalArgumentException("File cannot be null");
+ }
+
+ Files.createParentDirs(file);
+
+ final String data = saveToString();
+
+ final OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(file), UTF8);
+
+ try
+ {
+ writer.write(data);
+ }
+ finally
+ {
+ writer.close();
+ }
+ }
+
+ public Object getProperty(String path)
+ {
+ return get(path);
+ }
+
+ public void setProperty(String path, Object object)
+ {
+ set(path, object);
+ }
+
+ public void removeProperty(String path)
+ {
+ set(path, null);
+ }
+}
diff --git a/Essentials2Compat/src/com/earth2me/essentials/EssentialsUpgrade.java b/Essentials2Compat/src/com/earth2me/essentials/EssentialsUpgrade.java
new file mode 100644
index 000000000..97338579d
--- /dev/null
+++ b/Essentials2Compat/src/com/earth2me/essentials/EssentialsUpgrade.java
@@ -0,0 +1,729 @@
+package com.earth2me.essentials;
+
+import com.earth2me.essentials.economy.WorthHolder;
+import com.earth2me.essentials.storage.ManagedFile;
+import static com.earth2me.essentials.I18n._;
+import com.earth2me.essentials.api.IEssentials;
+import com.earth2me.essentials.settings.Spawns;
+import com.earth2me.essentials.storage.Location;
+import com.earth2me.essentials.storage.YamlStorageWriter;
+import java.io.*;
+import java.math.BigInteger;
+import java.security.DigestInputStream;
+import java.security.MessageDigest;
+import java.util.*;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.inventory.ItemStack;
+
+
+@Deprecated
+public class EssentialsUpgrade
+{
+ private final static Logger LOGGER = Logger.getLogger("Minecraft");
+ private final transient IEssentials ess;
+ private final transient EssentialsConf doneFile;
+
+ EssentialsUpgrade(final IEssentials essentials)
+ {
+ ess = essentials;
+ if (!ess.getDataFolder().exists())
+ {
+ ess.getDataFolder().mkdirs();
+ }
+ doneFile = new EssentialsConf(new File(ess.getDataFolder(), "upgrades-done.yml"));
+ doneFile.load();
+ }
+
+ private void moveWorthValuesToWorthYml()
+ {
+ if (doneFile.getBoolean("moveWorthValuesToWorthYml", false))
+ {
+ return;
+ }
+ try
+ {
+ final File configFile = new File(ess.getDataFolder(), "config.yml");
+ if (!configFile.exists())
+ {
+ return;
+ }
+ final EssentialsConf conf = new EssentialsConf(configFile);
+ conf.load();
+ final WorthHolder worth = new WorthHolder(ess);
+ boolean found = false;
+ for (Material mat : Material.values())
+ {
+ final int id = mat.getId();
+ final double value = conf.getDouble("worth-" + id, Double.NaN);
+ if (!Double.isNaN(value))
+ {
+ found = true;
+ worth.setPrice(new ItemStack(mat, 1, (short)0, (byte)0), value);
+ }
+ }
+ if (found)
+ {
+ removeLinesFromConfig(configFile, "\\s*#?\\s*worth-[0-9]+.*", "# Worth values have been moved to worth.yml");
+ }
+ doneFile.setProperty("moveWorthValuesToWorthYml", true);
+ doneFile.save();
+ }
+ catch (Throwable e)
+ {
+ LOGGER.log(Level.SEVERE, _("upgradingFilesError"), e);
+ }
+ }
+
+ private void moveMotdRulesToFile(String name)
+ {
+ if (doneFile.getBoolean("move" + name + "ToFile", false))
+ {
+ return;
+ }
+ try
+ {
+ final File file = new File(ess.getDataFolder(), name + ".txt");
+ if (file.exists())
+ {
+ return;
+ }
+ final File configFile = new File(ess.getDataFolder(), "config.yml");
+ if (!configFile.exists())
+ {
+ return;
+ }
+ final EssentialsConf conf = new EssentialsConf(configFile);
+ conf.load();
+ List<String> lines = conf.getStringList(name);
+ if (lines != null && !lines.isEmpty())
+ {
+ if (!file.createNewFile())
+ {
+ throw new IOException("Failed to create file " + file);
+ }
+ PrintWriter writer = new PrintWriter(file);
+
+ for (String line : lines)
+ {
+ writer.println(line);
+ }
+ writer.close();
+ }
+ doneFile.setProperty("move" + name + "ToFile", true);
+ doneFile.save();
+ }
+ catch (Throwable e)
+ {
+ LOGGER.log(Level.SEVERE, _("upgradingFilesError"), e);
+ }
+ }
+
+ private void removeLinesFromConfig(File file, String regex, String info) throws Exception
+ {
+ boolean needUpdate = false;
+ final BufferedReader bReader = new BufferedReader(new FileReader(file));
+ final File tempFile = File.createTempFile("essentialsupgrade", ".tmp.yml", ess.getDataFolder());
+ final BufferedWriter bWriter = new BufferedWriter(new FileWriter(tempFile));
+ do
+ {
+ final String line = bReader.readLine();
+ if (line == null)
+ {
+ break;
+ }
+ if (line.matches(regex))
+ {
+ if (!needUpdate && info != null)
+ {
+ bWriter.write(info, 0, info.length());
+ bWriter.newLine();
+ }
+ needUpdate = true;
+ }
+ else
+ {
+ if (line.endsWith("\r\n"))
+ {
+ bWriter.write(line, 0, line.length() - 2);
+ }
+ else if (line.endsWith("\r") || line.endsWith("\n"))
+ {
+ bWriter.write(line, 0, line.length() - 1);
+ }
+ else
+ {
+ bWriter.write(line, 0, line.length());
+ }
+ bWriter.newLine();
+ }
+ }
+ while (true);
+ bReader.close();
+ bWriter.close();
+ if (needUpdate)
+ {
+ if (!file.renameTo(new File(file.getParentFile(), file.getName().concat("." + System.currentTimeMillis() + ".upgradebackup"))))
+ {
+ throw new Exception(_("configFileMoveError"));
+ }
+ if (!tempFile.renameTo(file))
+ {
+ throw new Exception(_("configFileRenameError"));
+ }
+ }
+ else
+ {
+ tempFile.delete();
+ }
+ }
+
+ private void updateUsersToNewDefaultHome()
+ {
+ if (doneFile.getBoolean("updateUsersToNewDefaultHome", false))
+ {
+ return;
+ }
+ final File userdataFolder = new File(ess.getDataFolder(), "userdata");
+ if (!userdataFolder.exists() || !userdataFolder.isDirectory())
+ {
+ return;
+ }
+ final File[] userFiles = userdataFolder.listFiles();
+
+ for (File file : userFiles)
+ {
+ if (!file.isFile() || !file.getName().endsWith(".yml"))
+ {
+ continue;
+ }
+ final EssentialsConf config = new EssentialsConf(file);
+ try
+ {
+ config.load();
+ if (config.hasProperty("home") && !config.hasProperty("home.default"))
+ {
+ @SuppressWarnings("unchecked")
+ final List<Object> vals = (List<Object>)config.getProperty("home");
+ if (vals == null)
+ {
+ continue;
+ }
+ World world = ess.getServer().getWorlds().get(0);
+ if (world != null)
+ {
+ final Location loc = new Location(
+ (String)vals.get(5),
+ ((Number)vals.get(0)).doubleValue(),
+ ((Number)vals.get(1)).doubleValue(),
+ ((Number)vals.get(2)).doubleValue(),
+ ((Number)vals.get(3)).floatValue(),
+ ((Number)vals.get(4)).floatValue());
+
+ final String worldName = world.getName().toLowerCase(Locale.ENGLISH);
+ if (worldName != null && !worldName.isEmpty())
+ {
+ config.removeProperty("home");
+ config.setProperty("home.default", worldName);
+ config.setProperty("home.worlds." + worldName, loc);
+ config.save();
+ }
+ }
+ }
+ }
+ catch (RuntimeException ex)
+ {
+ LOGGER.log(Level.INFO, "File: " + file.toString());
+ throw ex;
+ }
+ }
+ doneFile.setProperty("updateUsersToNewDefaultHome", true);
+ doneFile.save();
+ }
+
+ private void updateUsersPowerToolsFormat()
+ {
+ if (doneFile.getBoolean("updateUsersPowerToolsFormat", false))
+ {
+ return;
+ }
+ final File userdataFolder = new File(ess.getDataFolder(), "userdata");
+ if (!userdataFolder.exists() || !userdataFolder.isDirectory())
+ {
+ return;
+ }
+ final File[] userFiles = userdataFolder.listFiles();
+
+ for (File file : userFiles)
+ {
+ if (!file.isFile() || !file.getName().endsWith(".yml"))
+ {
+ continue;
+ }
+ final EssentialsConf config = new EssentialsConf(file);
+ try
+ {
+ config.load();
+ if (config.hasProperty("powertools"))
+ {
+ @SuppressWarnings("unchecked")
+ final Map<String, Object> powertools = config.getConfigurationSection("powertools").getValues(false);
+ if (powertools == null)
+ {
+ continue;
+ }
+ for (Map.Entry<String, Object> entry : powertools.entrySet())
+ {
+ if (entry.getValue() instanceof String)
+ {
+ List<String> temp = new ArrayList<String>();
+ temp.add((String)entry.getValue());
+ ((Map<String, Object>)powertools).put(entry.getKey(), temp);
+ }
+ }
+ config.save();
+ }
+ }
+ catch (RuntimeException ex)
+ {
+ LOGGER.log(Level.INFO, "File: " + file.toString());
+ throw ex;
+ }
+ }
+ doneFile.setProperty("updateUsersPowerToolsFormat", true);
+ doneFile.save();
+ }
+
+ private void updateUsersHomesFormat()
+ {
+ if (doneFile.getBoolean("updateUsersHomesFormat", false))
+ {
+ return;
+ }
+ final File userdataFolder = new File(ess.getDataFolder(), "userdata");
+ if (!userdataFolder.exists() || !userdataFolder.isDirectory())
+ {
+ return;
+ }
+ final File[] userFiles = userdataFolder.listFiles();
+
+ for (File file : userFiles)
+ {
+ if (!file.isFile() || !file.getName().endsWith(".yml"))
+ {
+ continue;
+ }
+ final EssentialsConf config = new EssentialsConf(file);
+ try
+ {
+
+ config.load();
+ if (config.hasProperty("home") && config.hasProperty("home.default"))
+ {
+ @SuppressWarnings("unchecked")
+ final String defworld = (String)config.getProperty("home.default");
+ final Location defloc = getFakeLocation(config, "home.worlds." + defworld);
+ if (defloc != null)
+ {
+ config.setProperty("homes.home", defloc);
+ }
+
+ Set<String> worlds = config.getConfigurationSection("home.worlds").getKeys(false);
+ Location loc;
+ String worldName;
+
+ if (worlds == null)
+ {
+ continue;
+ }
+ for (String world : worlds)
+ {
+ if (defworld.equalsIgnoreCase(world))
+ {
+ continue;
+ }
+ loc = getFakeLocation(config, "home.worlds." + world);
+ if (loc == null)
+ {
+ continue;
+ }
+ worldName = loc.getWorldName().toLowerCase(Locale.ENGLISH);
+ if (worldName != null && !worldName.isEmpty())
+ {
+ config.setProperty("homes." + worldName, loc);
+ }
+ }
+ config.removeProperty("home");
+ config.save();
+ }
+
+ }
+ catch (RuntimeException ex)
+ {
+ LOGGER.log(Level.INFO, "File: " + file.toString());
+ throw ex;
+ }
+ }
+ doneFile.setProperty("updateUsersHomesFormat", true);
+ doneFile.save();
+ }
+
+ /*
+ * private void moveUsersDataToUserdataFolder() { final File usersFile = new File(ess.getDataFolder(), "users.yml");
+ * if (!usersFile.exists()) { return; } final EssentialsConf usersConfig = new EssentialsConf(usersFile);
+ * usersConfig.load(); for (String username : usersConfig.getKeys(null)) { final User user = new User(new
+ * OfflinePlayer(username, ess), ess); final String nickname = usersConfig.getString(username + ".nickname"); if
+ * (nickname != null && !nickname.isEmpty() && !nickname.equals(username)) { user.setNickname(nickname); } final
+ * List<String> mails = usersConfig.getStringList(username + ".mail", null); if (mails != null && !mails.isEmpty())
+ * { user.setMails(mails); } if (!user.hasHome()) { @SuppressWarnings("unchecked") final List<Object> vals =
+ * (List<Object>)usersConfig.getProperty(username + ".home"); if (vals != null) { World world =
+ * ess.getServer().getWorlds().get(0); if (vals.size() > 5) { world = getFakeWorld((String)vals.get(5)); } if (world
+ * != null) { user.setHome("home", new Location(world, ((Number)vals.get(0)).doubleValue(),
+ * ((Number)vals.get(1)).doubleValue(), ((Number)vals.get(2)).doubleValue(), ((Number)vals.get(3)).floatValue(),
+ * ((Number)vals.get(4)).floatValue())); } } } } usersFile.renameTo(new File(usersFile.getAbsolutePath() + ".old"));
+ * }
+ */
+
+ private void convertWarps()
+ {
+ final File warpsFolder = new File(ess.getDataFolder(), "warps");
+ if (!warpsFolder.exists())
+ {
+ warpsFolder.mkdirs();
+ }
+ final File[] listOfFiles = warpsFolder.listFiles();
+ if (listOfFiles.length >= 1)
+ {
+ for (int i = 0; i < listOfFiles.length; i++)
+ {
+ final String filename = listOfFiles[i].getName();
+ if (listOfFiles[i].isFile() && filename.endsWith(".dat"))
+ {
+ try
+ {
+ final BufferedReader rx = new BufferedReader(new FileReader(listOfFiles[i]));
+ double x, y, z;
+ float yaw, pitch;
+ String worldName;
+ try
+ {
+ if (!rx.ready())
+ {
+ continue;
+ }
+ x = Double.parseDouble(rx.readLine().trim());
+ if (!rx.ready())
+ {
+ continue;
+ }
+ y = Double.parseDouble(rx.readLine().trim());
+ if (!rx.ready())
+ {
+ continue;
+ }
+ z = Double.parseDouble(rx.readLine().trim());
+ if (!rx.ready())
+ {
+ continue;
+ }
+ yaw = Float.parseFloat(rx.readLine().trim());
+ if (!rx.ready())
+ {
+ continue;
+ }
+ pitch = Float.parseFloat(rx.readLine().trim());
+ worldName = rx.readLine();
+ }
+ finally
+ {
+ rx.close();
+ }
+ if (worldName != null)
+ {
+ final Location loc = new Location(worldName, x, y, z, yaw, pitch);
+ ((Warps)ess.getWarps()).setWarp(filename.substring(0, filename.length() - 4), loc);
+ if (!listOfFiles[i].renameTo(new File(warpsFolder, filename + ".old")))
+ {
+ throw new Exception(_("fileRenameError", filename));
+ }
+ }
+
+ }
+ catch (Exception ex)
+ {
+ LOGGER.log(Level.SEVERE, null, ex);
+ }
+ }
+ }
+
+ }
+ /*final File warpFile = new File(ess.getDataFolder(), "warps.txt");
+ if (warpFile.exists())
+ {
+ try
+ {
+ final BufferedReader rx = new BufferedReader(new FileReader(warpFile));
+ try
+ {
+ for (String[] parts = new String[0]; rx.ready(); parts = rx.readLine().split(":"))
+ {
+ if (parts.length < 6)
+ {
+ continue;
+ }
+ final String name = parts[0];
+ final double x = Double.parseDouble(parts[1].trim());
+ final double y = Double.parseDouble(parts[2].trim());
+ final double z = Double.parseDouble(parts[3].trim());
+ final float yaw = Float.parseFloat(parts[4].trim());
+ final float pitch = Float.parseFloat(parts[5].trim());
+ if (name.isEmpty())
+ {
+ continue;
+ }
+ World w = null;
+ for (World world : ess.getServer().getWorlds())
+ {
+ if (world.getEnvironment() != World.Environment.NETHER)
+ {
+ w = world;
+ break;
+ }
+ }
+ final Location loc = new Location(name, x, y, z, yaw, pitch);
+ ess.getWarps().setWarp(name, loc);
+ if (!warpFile.renameTo(new File(ess.getDataFolder(), "warps.txt.old")))
+ {
+ throw new Exception(_("fileRenameError", "warps.txt"));
+ }
+ }
+ }
+ finally
+ {
+ rx.close();
+ }
+ }
+ catch (Exception ex)
+ {
+ LOGGER.log(Level.SEVERE, null, ex);
+ }
+ }*/
+ }
+
+ /*
+ * private void sanitizeAllUserFilenames() { if (doneFile.getBoolean("sanitizeAllUserFilenames", false)) { return; }
+ * final File usersFolder = new File(ess.getDataFolder(), "userdata"); if (!usersFolder.exists()) { return; } final
+ * File[] listOfFiles = usersFolder.listFiles(); for (int i = 0; i < listOfFiles.length; i++) { final String
+ * filename = listOfFiles[i].getName(); if (!listOfFiles[i].isFile() || !filename.endsWith(".yml")) { continue; }
+ * final String sanitizedFilename = Util.sanitizeFileName(filename.substring(0, filename.length() - 4)) + ".yml"; if
+ * (sanitizedFilename.equals(filename)) { continue; } final File tmpFile = new File(listOfFiles[i].getParentFile(),
+ * sanitizedFilename + ".tmp"); final File newFile = new File(listOfFiles[i].getParentFile(), sanitizedFilename); if
+ * (!listOfFiles[i].renameTo(tmpFile)) { LOGGER.log(Level.WARNING, _("userdataMoveError", filename,
+ * sanitizedFilename)); continue; } if (newFile.exists()) { LOGGER.log(Level.WARNING, _("duplicatedUserdata",
+ * filename, sanitizedFilename)); continue; } if (!tmpFile.renameTo(newFile)) { LOGGER.log(Level.WARNING,
+ * _("userdataMoveBackError", sanitizedFilename, sanitizedFilename)); } }
+ * doneFile.setProperty("sanitizeAllUserFilenames", true); doneFile.save(); }
+ */
+ /*
+ * private World getFakeWorld(final String name) { final File bukkitDirectory =
+ * ess.getDataFolder().getParentFile().getParentFile(); final File worldDirectory = new File(bukkitDirectory, name);
+ * if (worldDirectory.exists() && worldDirectory.isDirectory()) { return new FakeWorld(worldDirectory.getName(),
+ * World.Environment.NORMAL); } return null;
+ }
+ */
+ public Location getFakeLocation(EssentialsConf config, String path)
+ {
+ String worldName = config.getString((path != null ? path + "." : "") + "world");
+ if (worldName == null || worldName.isEmpty())
+ {
+ return null;
+ }
+ return new Location(worldName,
+ config.getDouble((path != null ? path + "." : "") + "x", 0),
+ config.getDouble((path != null ? path + "." : "") + "y", 0),
+ config.getDouble((path != null ? path + "." : "") + "z", 0),
+ (float)config.getDouble((path != null ? path + "." : "") + "yaw", 0),
+ (float)config.getDouble((path != null ? path + "." : "") + "pitch", 0));
+ }
+
+ private void deleteOldItemsCsv()
+ {
+ if (doneFile.getBoolean("deleteOldItemsCsv", false))
+ {
+ return;
+ }
+ final File file = new File(ess.getDataFolder(), "items.csv");
+ if (file.exists())
+ {
+ try
+ {
+ final Set<BigInteger> oldconfigs = new HashSet<BigInteger>();
+ oldconfigs.add(new BigInteger("66ec40b09ac167079f558d1099e39f10", 16)); // sep 1
+ oldconfigs.add(new BigInteger("34284de1ead43b0bee2aae85e75c041d", 16)); // crlf
+ oldconfigs.add(new BigInteger("c33bc9b8ee003861611bbc2f48eb6f4f", 16)); // jul 24
+ oldconfigs.add(new BigInteger("6ff17925430735129fc2a02f830c1daa", 16)); // crlf
+
+ MessageDigest digest = ManagedFile.getDigest();
+ final BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
+ final DigestInputStream dis = new DigestInputStream(bis, digest);
+ final byte[] buffer = new byte[1024];
+ try
+ {
+ while (dis.read(buffer) != -1)
+ {
+ }
+ }
+ finally
+ {
+ dis.close();
+ }
+
+ BigInteger hash = new BigInteger(1, digest.digest());
+ if (oldconfigs.contains(hash) && !file.delete())
+ {
+ throw new IOException("Could not delete file " + file.toString());
+ }
+ doneFile.setProperty("deleteOldItemsCsv", true);
+ doneFile.save();
+ }
+ catch (IOException ex)
+ {
+ Bukkit.getLogger().log(Level.SEVERE, ex.getMessage(), ex);
+ }
+ }
+ }
+
+ private void updateSpawnsToNewSpawnsConfig()
+ {
+ if (doneFile.getBoolean("updateSpawnsToNewSpawnsConfig", false))
+ {
+ return;
+ }
+ final File configFile = new File(ess.getDataFolder(), "spawn.yml");
+ if (configFile.exists())
+ {
+
+ final EssentialsConf config = new EssentialsConf(configFile);
+ try
+ {
+ config.load();
+ if (!config.hasProperty("spawns"))
+ {
+ final Spawns spawns = new Spawns();
+ Set<String> keys = config.getKeys(false);
+ for (String group : keys)
+ {
+ Location loc = getFakeLocation(config, group);
+ spawns.getSpawns().put(group.toLowerCase(Locale.ENGLISH), loc);
+ }
+ if (!configFile.renameTo(new File(ess.getDataFolder(), "spawn.yml.old")))
+ {
+ throw new Exception(_("fileRenameError", "spawn.yml"));
+ }
+ PrintWriter writer = new PrintWriter(configFile);
+ try
+ {
+ new YamlStorageWriter(writer).save(spawns);
+ }
+ finally
+ {
+ writer.close();
+ }
+ }
+ }
+ catch (Exception ex)
+ {
+ Bukkit.getLogger().log(Level.SEVERE, ex.getMessage(), ex);
+ }
+ }
+ doneFile.setProperty("updateSpawnsToNewSpawnsConfig", true);
+ doneFile.save();
+ }
+
+ private void updateJailsToNewJailsConfig()
+ {
+ if (doneFile.getBoolean("updateJailsToNewJailsConfig", false))
+ {
+ return;
+ }
+ final File configFile = new File(ess.getDataFolder(), "jail.yml");
+ if (configFile.exists())
+ {
+
+ final EssentialsConf config = new EssentialsConf(configFile);
+ try
+ {
+ config.load();
+ if (!config.hasProperty("jails"))
+ {
+ final com.earth2me.essentials.settings.Jails jails = new com.earth2me.essentials.settings.Jails();
+ Set<String> keys = config.getKeys(false);
+ for (String jailName : keys)
+ {
+ Location loc = getFakeLocation(config, jailName);
+ jails.getJails().put(jailName.toLowerCase(Locale.ENGLISH), loc);
+ }
+ if (!configFile.renameTo(new File(ess.getDataFolder(), "jail.yml.old")))
+ {
+ throw new Exception(_("fileRenameError", "jail.yml"));
+ }
+ PrintWriter writer = new PrintWriter(configFile);
+ try
+ {
+ new YamlStorageWriter(writer).save(jails);
+ }
+ finally
+ {
+ writer.close();
+ }
+ }
+ }
+ catch (Exception ex)
+ {
+ Bukkit.getLogger().log(Level.SEVERE, ex.getMessage(), ex);
+ }
+ }
+ doneFile.setProperty("updateJailsToNewJailsConfig", true);
+ doneFile.save();
+ }
+
+ private void warnMetrics()
+ {
+ if (doneFile.getBoolean("warnMetrics", false))
+ {
+ return;
+ }
+ ess.getSettings().setMetricsEnabled(false);
+ doneFile.setProperty("warnMetrics", true);
+ doneFile.save();
+ }
+
+ public void beforeSettings()
+ {
+ if (!ess.getDataFolder().exists())
+ {
+ ess.getDataFolder().mkdirs();
+ }
+ moveWorthValuesToWorthYml();
+ moveMotdRulesToFile("motd");
+ moveMotdRulesToFile("rules");
+ }
+
+ public void afterSettings()
+ {
+ //TODO?
+ //sanitizeAllUserFilenames();
+ updateUsersToNewDefaultHome();
+ //moveUsersDataToUserdataFolder();
+ convertWarps();
+ updateUsersPowerToolsFormat();
+ updateUsersHomesFormat();
+ deleteOldItemsCsv();
+ updateSpawnsToNewSpawnsConfig();
+ updateJailsToNewJailsConfig();
+ warnMetrics();
+ }
+}
diff --git a/Essentials2Compat/src/com/earth2me/essentials/api/Economy.java b/Essentials2Compat/src/com/earth2me/essentials/api/Economy.java
new file mode 100644
index 000000000..cf8cb640c
--- /dev/null
+++ b/Essentials2Compat/src/com/earth2me/essentials/api/Economy.java
@@ -0,0 +1,231 @@
+package com.earth2me.essentials.api;
+
+import com.earth2me.essentials.utils.Util;
+
+
+/**
+ * Instead of using this api directly, we recommend to use the register plugin:
+ * http://bit.ly/RegisterMethod
+ */
+public final class Economy
+{
+ private Economy()
+ {
+ }
+ private static IEssentials ess;
+ private static final String noCallBeforeLoad = "Essentials API is called before Essentials is loaded.";
+
+ /**
+ * Returns the balance of a user
+ * @param name Name of the user
+ * @return balance
+ * @throws UserDoesNotExistException
+ */
+ public static double getMoney(String name) throws UserDoesNotExistException
+ {
+ if (ess == null)
+ {
+ throw new RuntimeException(noCallBeforeLoad);
+ }
+ return ess.getEconomy().getMoney(name);
+ }
+
+ /**
+ * Sets the balance of a user
+ * @param name Name of the user
+ * @param balance The balance you want to set
+ * @throws UserDoesNotExistException If a user by that name does not exists
+ * @throws NoLoanPermittedException If the user is not allowed to have a negative balance
+ */
+ public static void setMoney(String name, double balance) throws UserDoesNotExistException, NoLoanPermittedException
+ {
+ if (ess == null)
+ {
+ throw new RuntimeException(noCallBeforeLoad);
+ }
+ ess.getEconomy().setMoney(name, balance);
+ }
+
+ /**
+ * Adds money to the balance of a user
+ * @param name Name of the user
+ * @param amount The money you want to add
+ * @throws UserDoesNotExistException If a user by that name does not exists
+ * @throws NoLoanPermittedException If the user is not allowed to have a negative balance
+ */
+ public static void add(String name, double amount) throws UserDoesNotExistException, NoLoanPermittedException
+ {
+ double result = getMoney(name) + amount;
+ setMoney(name, result);
+ }
+
+ /**
+ * Substracts money from the balance of a user
+ * @param name Name of the user
+ * @param amount The money you want to substract
+ * @throws UserDoesNotExistException If a user by that name does not exists
+ * @throws NoLoanPermittedException If the user is not allowed to have a negative balance
+ */
+ public static void subtract(String name, double amount) throws UserDoesNotExistException, NoLoanPermittedException
+ {
+ double result = getMoney(name) - amount;
+ setMoney(name, result);
+ }
+
+ /**
+ * Divides the balance of a user by a value
+ * @param name Name of the user
+ * @param value The balance is divided by this value
+ * @throws UserDoesNotExistException If a user by that name does not exists
+ * @throws NoLoanPermittedException If the user is not allowed to have a negative balance
+ */
+ public static void divide(String name, double value) throws UserDoesNotExistException, NoLoanPermittedException
+ {
+ double result = getMoney(name) / value;
+ setMoney(name, result);
+ }
+
+ /**
+ * Multiplies the balance of a user by a value
+ * @param name Name of the user
+ * @param value The balance is multiplied by this value
+ * @throws UserDoesNotExistException If a user by that name does not exists
+ * @throws NoLoanPermittedException If the user is not allowed to have a negative balance
+ */
+ public static void multiply(String name, double value) throws UserDoesNotExistException, NoLoanPermittedException
+ {
+ double result = getMoney(name) * value;
+ setMoney(name, result);
+ }
+
+ /**
+ * Resets the balance of a user to the starting balance
+ * @param name Name of the user
+ * @throws UserDoesNotExistException If a user by that name does not exists
+ * @throws NoLoanPermittedException If the user is not allowed to have a negative balance
+ */
+ public static void resetBalance(String name) throws UserDoesNotExistException, NoLoanPermittedException
+ {
+ if (ess == null)
+ {
+ throw new RuntimeException(noCallBeforeLoad);
+ }
+ ess.getEconomy().resetBalance(name);
+ }
+
+ /**
+ * @param name Name of the user
+ * @param amount The amount of money the user should have
+ * @return true, if the user has more or an equal amount of money
+ * @throws UserDoesNotExistException If a user by that name does not exists
+ */
+ public static boolean hasEnough(String name, double amount) throws UserDoesNotExistException
+ {
+ return amount <= getMoney(name);
+ }
+
+ /**
+ * @param name Name of the user
+ * @param amount The amount of money the user should have
+ * @return true, if the user has more money
+ * @throws UserDoesNotExistException If a user by that name does not exists
+ */
+ public static boolean hasMore(String name, double amount) throws UserDoesNotExistException
+ {
+ return amount < getMoney(name);
+ }
+
+ /**
+ * @param name Name of the user
+ * @param amount The amount of money the user should not have
+ * @return true, if the user has less money
+ * @throws UserDoesNotExistException If a user by that name does not exists
+ */
+ public static boolean hasLess(String name, double amount) throws UserDoesNotExistException
+ {
+ return amount > getMoney(name);
+ }
+
+ /**
+ * Test if the user has a negative balance
+ * @param name Name of the user
+ * @return true, if the user has a negative balance
+ * @throws UserDoesNotExistException If a user by that name does not exists
+ */
+ public static boolean isNegative(String name) throws UserDoesNotExistException
+ {
+ return getMoney(name) < 0.0;
+ }
+
+ /**
+ * Formats the amount of money like all other Essentials functions.
+ * Example: $100000 or $12345.67
+ * @param amount The amount of money
+ * @return Formatted money
+ */
+ public static String format(double amount)
+ {
+ if (ess == null)
+ {
+ throw new RuntimeException(noCallBeforeLoad);
+ }
+ return Util.displayCurrency(amount, ess);
+ }
+
+ /**
+ * Test if a player exists to avoid the UserDoesNotExistException
+ * @param name Name of the user
+ * @return true, if the user exists
+ */
+ public static boolean playerExists(String name)
+ {
+ if (ess == null)
+ {
+ throw new RuntimeException(noCallBeforeLoad);
+ }
+ return ess.getEconomy().playerExists(name);
+ }
+
+ /**
+ * Test if a player is a npc
+ * @param name Name of the player
+ * @return true, if it's a npc
+ * @throws UserDoesNotExistException
+ */
+ public static boolean isNPC(String name) throws UserDoesNotExistException
+ {
+ if (ess == null)
+ {
+ throw new RuntimeException(noCallBeforeLoad);
+ }
+ return ess.getEconomy().isNPC(name);
+ }
+
+ /**
+ * Creates dummy files for a npc, if there is no player yet with that name.
+ * @param name Name of the player
+ * @return true, if a new npc was created
+ */
+ public static boolean createNPC(String name)
+ {
+ if (ess == null)
+ {
+ throw new RuntimeException(noCallBeforeLoad);
+ }
+ return ess.getEconomy().createNPC(name);
+ }
+
+ /**
+ * Deletes a user, if it is marked as npc.
+ * @param name Name of the player
+ * @throws UserDoesNotExistException
+ */
+ public static void removeNPC(String name) throws UserDoesNotExistException
+ {
+ if (ess == null)
+ {
+ throw new RuntimeException(noCallBeforeLoad);
+ }
+ ess.getEconomy().removeNPC(name);
+ }
+}