diff options
Diffstat (limited to 'Essentials2Compat/src/com')
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); + } +} |