hhgyujkh

package de.gabik21.hospitalcore;

import java.io.File;
import java.io.IOException;
import java.io.PrintStream;
import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.configuration.file.FileConfigurationOptions;
import org.bukkit.configuration.file.YamlConfiguration;

public class MySQLFile
{
  public void setStandard()
  {
    FileConfiguration cfg = getFileConfiguration();

    cfg.options().copyDefaults(true);

    cfg.addDefault("host", "mysql.mc-host24.de");
    cfg.addDefault("port", "3306");
    cfg.addDefault("database", "db_41955");
    cfg.addDefault("username", "db_41955");
    cfg.addDefault("password", "b83b3f4f54");
    try
    {
      cfg.save(getFile());
    }
    catch (IOException e)
    {
      e.printStackTrace();
    }
  }

  private File getFile()
  {
    return new File("plugins/HospitalCore", "mysql.yml");
  }

  private FileConfiguration getFileConfiguration()
  {
    return YamlConfiguration.loadConfiguration(getFile());
  }

  public void readData()
  {
    FileConfiguration cfg = getFileConfiguration();
    if (!getFile().exists()) {
      setStandard();
    }
    MySQL.host = cfg.getString("host");
    MySQL.port = cfg.getString("port");
    MySQL.database = cfg.getString("database");
    MySQL.username = cfg.getString("username");
    MySQL.password = cfg.getString("password");

    System.out.println(MySQL.host);
  }
}





package de.gabik21.hospitalcore;

import java.io.PrintStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class MySQL
{
  public static String host;
  public static String port;
  public static String database;
  public static String username;
  public static String password;
  public static Connection con;

  public static void connect()
  {
    if (!isConnected()) {
      try
      {
        con = DriverManager.getConnection("jdbc:mysql://" + host +
          ":3306/" + database, username, password);
        System.out.println("[Hospital] MySQL Verbindung aufgebaut!");
      }
      catch (SQLException e)
      {
        e.printStackTrace();
      }
    }
  }

  public static void disconnect()
  {
    try
    {
      con.close();
      System.out.println("[Hospital] MySQL Verbindung geschlossen");
    }
    catch (SQLException e)
    {
      e.printStackTrace();
    }
  }

  public static boolean isConnected()
  {
    if (con == null) {
      return false;
    }
    try
    {
      if (!con.isValid(1000)) {
        return false;
      }
    }
    catch (SQLException e)
    {
      e.printStackTrace();
    }
    return true;
  }

  public static int executeUpdate(String s)
  {
    try
    {
      PreparedStatement ps = getConnection().prepareStatement(s);
      return ps.executeUpdate();
    }
    catch (SQLException e)
    {
      e.printStackTrace();
    }
    return -1;
  }

  public static ResultSet executeQuery(String s)
  {
    try
    {
      PreparedStatement ps = getConnection().prepareStatement(s);
      return ps.executeQuery();
    }
    catch (SQLException e)
    {
      e.printStackTrace();
    }
    return null;
  }

  public static Connection getConnection()
  {
    if (!isConnected()) {
      connect();
    }
    return con;
  }
}




package de.gabik21.hospitalcore.util;

import java.util.ArrayList;
import java.util.List;

public enum BanUnit
{
  SECONDS(
    "Sekunde(n)",
    1L,
    "s"),  MINUTES(
    "Minuten(n)",
    60L,
    "m"),  HOUR(
    "Stunde(n)",
    3600L,
    "h"),  DAY(
    "Tag(e)",
    86400L,
    "d"),  WEEK(
    "Woche(n)",
    604800L,
    "w");

  private String name;
  private long toSecond;
  private String shortcut;

  private BanUnit(String name, long toSecond, String shortcut)
  {
    this.name = name;
    this.toSecond = toSecond;
    this.shortcut = shortcut;
  }

  public long getToSecond()
  {
    return this.toSecond;
  }

  public String getName()
  {
    return this.name;
  }

  public String getShortcut()
  {
    return this.shortcut;
  }

  public static List<String> getUnitsAsString()
  {
    List<String> units = new ArrayList();
    BanUnit[] arrayOfBanUnit;
    int j = (arrayOfBanUnit = values()).length;
    for (int i = 0; i < j; i++)
    {
      BanUnit unit = arrayOfBanUnit[i];
      units.add(unit.getShortcut().toLowerCase());
    }
    return units;
  }

  public static BanUnit getUnit(String unit)
  {
    BanUnit[] arrayOfBanUnit;
    int j = (arrayOfBanUnit = values()).length;
    for (int i = 0; i < j; i++)
    {
      BanUnit units = arrayOfBanUnit[i];
      if (units.getShortcut().toLowerCase().equals(unit.toLowerCase())) {
        return units;
      }
    }
    return null;
  }
}





package de.gabik21.hospitalcore.util;

import de.gabik21.hospitalcore.MySQL;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.UUID;
import org.bukkit.Bukkit;
import org.bukkit.OfflinePlayer;
import org.bukkit.command.CommandSender;

public class BanManager
{
  public static void ban(String uuid, String playername, String reason, long seconds, String banner)
  {
    long end = 0L;
    if (seconds == -1L) {
      end = -1L;
    } else {
      end = System.currentTimeMillis() + seconds * 1000L;
    }
    String raw = "INSERT INTO bans (Name, UUID, End, Reason, Banner) VALUES('%s','%s','%s','%s','%s')";
    String qry = String.format(raw, new Object[] { playername, uuid, String.valueOf(end),
      reason, banner });

    MySQL.executeUpdate(qry);
  }

  public static void unban(String uuid)
  {
    try
    {
      PreparedStatement ps = MySQL.getConnection().prepareStatement(
        "DELETE FROM bans WHERE UUID = ?");
      ps.setString(1, uuid);

      ps.executeUpdate();
    }
    catch (SQLException e)
    {
      e.printStackTrace();
    }
  }

  public static boolean isBanned(String uuid)
  {
    if (getEnd(uuid) == null) {
      return false;
    }
    if ((System.currentTimeMillis() > getEnd(uuid).longValue()) && (getEnd(uuid).longValue() > -1L))
    {
      unban(uuid);
      return false;
    }
    return true;
  }

  public static String getReason(String uuid)
  {
    ResultSet rs =
      MySQL.executeQuery("SELECT Reason FROM bans WHERE UUID = '" + uuid +
      "'");
    try
    {
      if (rs.next()) {
        return rs.getString("Reason");
      }
    }
    catch (SQLException e)
    {
      e.printStackTrace();
    }
    return null;
  }

  public static String getBanner(String uuid)
  {
    ResultSet rs =
      MySQL.executeQuery("SELECT Banner FROM bans WHERE UUID = '" + uuid +
      "'");
    try
    {
      if (rs.next()) {
        return rs.getString("Banner");
      }
    }
    catch (SQLException e)
    {
      e.printStackTrace();
    }
    return null;
  }

  public static Long getEnd(String uuid)
  {
    ResultSet rs = MySQL.executeQuery("SELECT End FROM bans WHERE UUID = '" +
      uuid + "'");
    try
    {
      if (rs.next()) {
        return Long.valueOf(rs.getLong("End"));
      }
    }
    catch (SQLException e)
    {
      e.printStackTrace();
    }
    return null;
  }

  public static List<String> getBannedPlayersBy(CommandSender sender, String banner)
  {
    List<String> temp = new ArrayList();

    ResultSet rs =
      MySQL.executeQuery("SELECT Name FROM bans WHERE Banner = '" + banner +
      "'");
    try
    {
      while (rs.next()) {
        temp.add(rs.getString("Name"));
      }
    }
    catch (SQLException e)
    {
      e.printStackTrace();
    }
    Iterator<String> litr = temp.iterator();
    while (litr.hasNext())
    {
      String s = (String)litr.next();

      OfflinePlayer p = Bukkit.getOfflinePlayer(s);
      if ((p != null) && (!isBanned(p.getUniqueId().toString()))) {
        litr.remove();
      } else {
        sender.sendMessage("�e" + s);
      }
    }
    sender.sendMessage("�e" + temp.size() + " players banned in total");

    return temp;
  }

  public static List<String> getBannedPlayers(CommandSender sender)
  {
    List<String> temp = new ArrayList();

    ResultSet rs = MySQL.executeQuery("SELECT Name FROM bans");
    try
    {
      while (rs.next()) {
        temp.add(rs.getString("Name"));
      }
    }
    catch (SQLException e)
    {
      e.printStackTrace();
    }
    Iterator<String> litr = temp.iterator();
    while (litr.hasNext())
    {
      String s = (String)litr.next();

      OfflinePlayer p = Bukkit.getOfflinePlayer(s);
      if ((p != null) && (!isBanned(p.getUniqueId().toString()))) {
        litr.remove();
      } else {
        sender.sendMessage("�e" + s);
      }
    }
    sender.sendMessage("�e" + temp.size() + " players banned in total");

    return temp;
  }

  public static String getRemainingTime(String uuid)
  {
    if (getEnd(uuid).longValue() == -1L) {
      return "�4Permanent";
    }
    long time = getEnd(uuid).longValue() - System.currentTimeMillis();

    long seconds = 0L;
    long minutes = 0L;
    long hours = 0L;
    long days = 0L;
    while (time >= 1000L)
    {
      time -= 1000L;
      seconds += 1L;
    }
    while (seconds >= 60L)
    {
      seconds -= 60L;
      minutes += 1L;
    }
    while (minutes >= 60L)
    {
      minutes -= 60L;
      hours += 1L;
    }
    while (hours >= 24L)
    {
      hours -= 24L;
      days += 1L;
    }
    String returnstring = "�c";
    if (days > 0L) {
      returnstring = returnstring + days + " day(s) ";
    }
    if (hours > 0L) {
      returnstring = returnstring + hours + " hour(s) ";
    }
    if (minutes > 0L) {
      returnstring = returnstring + minutes + " minute(s) ";
    }
    if (seconds > 0L) {
      returnstring = returnstring + seconds + " second(s)";
    }
    return returnstring;
  }
}





package de.gabik21.hospitalcore.util;

import de.gabik21.hospitalcore.MySQL;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.UUID;
import org.bukkit.Bukkit;
import org.bukkit.OfflinePlayer;
import org.bukkit.command.CommandSender;

public class MuteManager
{
  public static void mute(String uuid, String playername, String reason, long seconds, String muter)
  {
    long end = 0L;
    if (seconds == -1L) {
      end = -1L;
    } else {
      end = System.currentTimeMillis() + seconds * 1000L;
    }
    try
    {
      PreparedStatement ps =
        MySQL.getConnection()
        .prepareStatement(
        "INSERT INTO mutes (Name, UUID, End, Reason, Muter) VALUES(?,?,?,?,?)");
      ps.setString(1, playername);
      ps.setString(2, uuid);
      ps.setString(3, String.valueOf(end));
      ps.setString(4, reason);
      ps.setString(5, muter);

      ps.executeUpdate();
    }
    catch (SQLException e)
    {
      e.printStackTrace();
    }
  }

  public static void unmute(String uuid)
  {
    try
    {
      PreparedStatement ps = MySQL.getConnection().prepareStatement(
        "DELETE FROM mutes WHERE UUID = ?");
      ps.setString(1, uuid);

      ps.executeUpdate();
    }
    catch (SQLException e)
    {
      e.printStackTrace();
    }
  }

  public static boolean isMuted(String uuid)
  {
    if (getEnd(uuid) == null) {
      return false;
    }
    if ((System.currentTimeMillis() > getEnd(uuid).longValue()) && (getEnd(uuid).longValue() > -1L))
    {
      unmute(uuid);
      return false;
    }
    return true;
  }

  public static String getReason(String uuid)
  {
    try
    {
      PreparedStatement ps = MySQL.getConnection().prepareStatement(
        "SELECT * FROM mutes WHERE UUID = ?");
      ps.setString(1, uuid);
      ResultSet rs = ps.executeQuery();
      if (rs.next()) {
        return rs.getString("Reason");
      }
    }
    catch (SQLException e)
    {
      e.printStackTrace();
    }
    return null;
  }

  public static String getMuter(String uuid)
  {
    try
    {
      PreparedStatement ps = MySQL.getConnection().prepareStatement(
        "SELECT * FROM mutes WHERE UUID = ?");
      ps.setString(1, uuid);
      ResultSet rs = ps.executeQuery();
      if (rs.next()) {
        return rs.getString("Muter");
      }
    }
    catch (SQLException e)
    {
      e.printStackTrace();
    }
    return null;
  }

  public static Long getEnd(String uuid)
  {
    try
    {
      PreparedStatement ps = MySQL.getConnection().prepareStatement(
        "SELECT * FROM mutes WHERE UUID = ?");
      ps.setString(1, uuid);
      ResultSet rs = ps.executeQuery();
      if (rs.next()) {
        return Long.valueOf(rs.getLong("End"));
      }
    }
    catch (SQLException e)
    {
      e.printStackTrace();
    }
    return null;
  }

  public static List<String> getMutedPlayers(CommandSender sender)
  {
    List<String> temp = new ArrayList();
    try
    {
      PreparedStatement ps = MySQL.getConnection().prepareStatement(
        "SELECT * FROM mutes");
      ResultSet rs = ps.executeQuery();
      while (rs.next()) {
        temp.add(rs.getString("Name"));
      }
    }
    catch (SQLException e)
    {
      e.printStackTrace();
    }
    Iterator<String> litr = temp.iterator();
    while (litr.hasNext())
    {
      String s = (String)litr.next();

      OfflinePlayer p = Bukkit.getOfflinePlayer(s);
      if ((p != null) && (!isMuted(p.getUniqueId().toString()))) {
        litr.remove();
      } else {
        sender.sendMessage("�e" + s);
      }
    }
    sender.sendMessage("�e" + temp.size() + " players muted in total");
    return temp;
  }

  public static String getRemainingTime(String uuid)
  {
    if (getEnd(uuid).longValue() == -1L) {
      return "�4Permanent";
    }
    long time = getEnd(uuid).longValue() - System.currentTimeMillis();

    long seconds = 0L;
    long minutes = 0L;
    long hours = 0L;
    long days = 0L;
    while (time >= 1000L)
    {
      time -= 1000L;
      seconds += 1L;
    }
    while (seconds >= 60L)
    {
      seconds -= 60L;
      minutes += 1L;
    }
    while (minutes >= 60L)
    {
      minutes -= 60L;
      hours += 1L;
    }
    while (hours >= 24L)
    {
      hours -= 24L;
      days += 1L;
    }
    String returnstring = "�c";
    if (days > 0L) {
      returnstring = returnstring + days + " day(s) ";
    }
    if (hours > 0L) {
      returnstring = returnstring + hours + " hour(s) ";
    }
    if (minutes > 0L) {
      returnstring = returnstring + minutes + " minute(s) ";
    }
    if (seconds > 0L) {
      returnstring = returnstring + seconds + " second(s)";
    }
    return returnstring;
  }
}




package de.gabik21.hospitalcore.commands;

import de.gabik21.hospitalcore.HospitalCore;
import de.gabik21.hospitalcore.util.BanManager;
import de.gabik21.hospitalcore.util.BanUnit;
import java.util.List;
import java.util.UUID;
import org.bukkit.Bukkit;
import org.bukkit.OfflinePlayer;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.scheduler.BukkitRunnable;

public class BanCommand
  implements CommandExecutor
{
  public boolean onCommand(final CommandSender sender, Command cmd, String label, String[] args)
  {
    if ((!sender.hasPermission("Admin")) &&
      (!sender.hasPermission("Moderator")) &&
      (!sender.hasPermission("Supporter")))
    {
      sender.sendMessage("�cInsufficient permissions.");
      return true;
    }
    if (cmd.getName().equalsIgnoreCase("ban"))
    {
      if (args.length < 2) {
        return false;
      }
      final Player t = Bukkit.getPlayer(args[0]);
      final String toban = args[0];

      boolean kickt = false;
      if (t != null) {
        kickt = true;
      }
      final boolean kick = kickt;

      String reasonbuilder = "";
      for (int i = 1; i < args.length; i++) {
        reasonbuilder = reasonbuilder + args[i] + " ";
      }
      final String reason = reasonbuilder;

      new BukkitRunnable()
      {
        public void run()
        {
          UUID uuid = Bukkit.getOfflinePlayer(toban).getUniqueId();
          if (BanManager.isBanned(uuid.toString())) {
            BanManager.unban(uuid.toString());
          }
          BanManager.ban(uuid.toString(), toban, reason, -1L,
            sender.getName());

          final String remaining = BanManager.getRemainingTime(uuid
            .toString());

          new BukkitRunnable()
          {
            public void run()
            {
              Bukkit.broadcastMessage("�c-------------\n�c" +
                this.val$sender.getName() + " banned player " +
                this.val$toban + "\nTime: " + "forever \nReason: " +
                this.val$reason + "\n�c-------------");
              if (this.val$kick) {
                this.val$t.kickPlayer("�c-------------\n�cYou have been banned from the server. \nReason: " +
                  this.val$reason +
                  "\nRemaining time: " +
                  remaining + "\n �c-------------");
              }
            }
          }.runTask(HospitalCore.getInstance());
        }
      }.runTaskAsynchronously(HospitalCore.getInstance());

      return true;
    }
    if (cmd.getName().equalsIgnoreCase("tempban"))
    {
      if (args.length < 4) {
        return false;
      }
      final Player t = Bukkit.getPlayer(args[0]);
      final String toban = args[0];

      boolean kickt = false;
      if (t != null) {
        kickt = true;
      }
      final boolean kick = kickt;

      String reasonbuilder = "";
      for (int i = 3; i < args.length; i++) {
        reasonbuilder = reasonbuilder + args[i] + " ";
      }
      String unitString = args[2];
      List<String> unitList = BanUnit.getUnitsAsString();
      if (!unitList.contains(unitString.toLowerCase())) {
        return false;
      }
      final String reason = reasonbuilder;
      BanUnit unit = BanUnit.getUnit(unitString);
      try
      {
        timeint = Integer.valueOf(args[1]).intValue();
      }
      catch (NumberFormatException e)
      {
        int timeint;
        sender.sendMessage("�cValue is too high for an Integer. INTEGER_MAX_VALUE = 2147483647");

        return true;
      }
      int timeint;
      final long time = timeint * unit.getToSecond();

      new BukkitRunnable()
      {
        public void run()
        {
          UUID uuid = Bukkit.getOfflinePlayer(toban).getUniqueId();
          if (BanManager.isBanned(uuid.toString())) {
            BanManager.unban(uuid.toString());
          }
          BanManager.ban(uuid.toString(), toban, reason, time + 1L,
            kick.getName());

          final String remaining = BanManager.getRemainingTime(uuid
            .toString());

          new BukkitRunnable()
          {
            public void run()
            {
              Bukkit.broadcastMessage("�c-------------\n�c" +
                this.val$sender.getName() + " banned player " +
                this.val$toban + "\nTime: " + remaining +
                "\nReason: " + this.val$reason +
                "\n�c-------------");
              if (this.val$kick) {
                this.val$t.kickPlayer("�c-------------\nYou have been banned from the server. \nReason: " +
                  this.val$reason +
                  "\nRemaining time: " +
                  remaining + "\n�c-------------");
              }
            }
          }.runTask(HospitalCore.getInstance());
        }
      }.runTaskAsynchronously(HospitalCore.getInstance());

      return true;
    }
    if (cmd.getName().equalsIgnoreCase("unban"))
    {
      if (args.length != 1) {
        return false;
      }
      final String name = args[0];

      new BukkitRunnable()
      {
        public void run()
        {
          UUID uuid = Bukkit.getOfflinePlayer(name).getUniqueId();
          if (!BanManager.isBanned(uuid.toString()))
          {
            sender.sendMessage("�aIsn't banned.");
            return;
          }
          BanManager.unban(uuid.toString());

          new BukkitRunnable()
          {
            public void run()
            {
              Bukkit.broadcastMessage("�a" + this.val$name +
                " has been unbanned by " +
                this.val$sender.getName());
            }
          }.runTask(HospitalCore.getInstance());
        }
      }.runTaskAsynchronously(HospitalCore.getInstance());
      return true;
    }
    if (cmd.getName().equalsIgnoreCase("bancheck"))
    {
      if ((args.length == 2) && (args[0].equalsIgnoreCase("list")))
      {
        final String banner = args[1];

        new BukkitRunnable()
        {
          public void run()
          {
            BanManager.getBannedPlayersBy(sender, banner);
          }
        }.runTaskAsynchronously(HospitalCore.getInstance());

        return true;
      }
      if (args.length != 1) {
        return false;
      }
      final String name = args[0];

      new BukkitRunnable()
      {
        public void run()
        {
          if (name.equalsIgnoreCase("list"))
          {
            BanManager.getBannedPlayers(sender);
            return;
          }
          UUID uuid = Bukkit.getOfflinePlayer(name).getUniqueId();
          if (!BanManager.isBanned(uuid.toString()))
          {
            sender.sendMessage("�aThe player isn't banned");
          }
          else
          {
            sender.sendMessage("�c-------------");
            sender.sendMessage("�cName: " + name);
            sender.sendMessage("�cReason: " +
              BanManager.getReason(uuid.toString()));
            sender.sendMessage("�cTime left: " +
              BanManager.getRemainingTime(uuid.toString()));
            sender.sendMessage("�cBanned by: " +
              BanManager.getBanner(uuid.toString()));
            sender.sendMessage("�c-------------");
          }
        }
      }.runTaskAsynchronously(HospitalCore.getInstance());
    }
    return false;
  }
}




package de.gabik21.hospitalcore.commands;

import de.gabik21.hospitalcore.HospitalCore;
import de.gabik21.hospitalcore.util.BanUnit;
import de.gabik21.hospitalcore.util.MuteManager;
import java.util.List;
import java.util.UUID;
import org.bukkit.Bukkit;
import org.bukkit.OfflinePlayer;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.scheduler.BukkitRunnable;

public class MuteCommand
  implements CommandExecutor
{
  public boolean onCommand(final CommandSender sender, Command cmd, String label, String[] args)
  {
    if ((!sender.hasPermission("Owner")) &&
      (!sender.hasPermission("Moderator")) &&
      (!sender.hasPermission("Supporter")))
    {
      sender.sendMessage("�cInsufficient permissions.");
      return true;
    }
    if (cmd.getName().equalsIgnoreCase("mute"))
    {
      if (args.length < 2) {
        return false;
      }
      final String toban = args[0];

      String reasonbuilder = "";
      for (int i = 1; i < args.length; i++) {
        reasonbuilder = reasonbuilder + args[i] + " ";
      }
      final String reason = reasonbuilder;

      new BukkitRunnable()
      {
        public void run()
        {
          UUID uuid = Bukkit.getOfflinePlayer(toban).getUniqueId();
          if (MuteManager.isMuted(uuid.toString())) {
            MuteManager.unmute(uuid.toString());
          }
          MuteManager.mute(uuid.toString(), toban, reason, -1L,
            sender.getName());

          new BukkitRunnable()
          {
            public void run()
            {
              Bukkit.broadcastMessage("�c" + this.val$sender.getName() +
                " muted player " + this.val$toban + " for " +
                this.val$reason + " for a period of forever.");
            }
          }.runTask(HospitalCore.getInstance());
        }
      }.runTaskAsynchronously(HospitalCore.getInstance());

      return true;
    }
    if (cmd.getName().equalsIgnoreCase("tempmute"))
    {
      if (args.length < 4) {
        return false;
      }
      final String toban = args[0];

      String reasonbuilder = "";
      for (int i = 3; i < args.length; i++) {
        reasonbuilder = reasonbuilder + args[i] + " ";
      }
      String unitString = args[2];
      List<String> unitList = BanUnit.getUnitsAsString();
      if (!unitList.contains(unitString.toLowerCase())) {
        return false;
      }
      final String reason = reasonbuilder;
      BanUnit unit = BanUnit.getUnit(unitString);
      try
      {
        timeint = Integer.valueOf(args[1]).intValue();
      }
      catch (NumberFormatException e)
      {
        int timeint;
        sender.sendMessage("�cValue is too high for an Integer. INTEGER_MAX_VALUE = 2147483647");

        return true;
      }
      int timeint;
      final long time = timeint * unit.getToSecond();

      new BukkitRunnable()
      {
        public void run()
        {
          UUID uuid = Bukkit.getOfflinePlayer(toban).getUniqueId();
          if (MuteManager.isMuted(uuid.toString())) {
            MuteManager.unmute(uuid.toString());
          }
          MuteManager.mute(uuid.toString(), toban, reason, time + 1L,
            this.val$sender.getName());

          final String remaining = MuteManager.getRemainingTime(uuid
            .toString());

          new BukkitRunnable()
          {
            public void run()
            {
              Bukkit.broadcastMessage("�c" + this.val$sender.getName() +
                " muted player " + this.val$toban + " for " +
                this.val$reason + " for a period of " + remaining);
            }
          }.runTask(HospitalCore.getInstance());
        }
      }.runTaskAsynchronously(HospitalCore.getInstance());

      return true;
    }
    if (cmd.getName().equalsIgnoreCase("unmute"))
    {
      if (args.length != 1) {
        return false;
      }
      final String name = args[0];

      new BukkitRunnable()
      {
        public void run()
        {
          UUID uuid = Bukkit.getOfflinePlayer(name).getUniqueId();
          if (!MuteManager.isMuted(uuid.toString()))
          {
            sender.sendMessage("�aIsn't banned.");
            return;
          }
          MuteManager.unmute(uuid.toString());

          new BukkitRunnable()
          {
            public void run()
            {
              Bukkit.broadcastMessage("�a" + this.val$name +
                " has been unmuted by " +
                this.val$sender.getName());
            }
          }.runTask(HospitalCore.getInstance());
        }
      }.runTaskAsynchronously(HospitalCore.getInstance());
      return true;
    }
    if (cmd.getName().equalsIgnoreCase("mutecheck"))
    {
      if (args.length != 1) {
        return false;
      }
      final String name = args[0];

      new BukkitRunnable()
      {
        public void run()
        {
          if (name.equalsIgnoreCase("list"))
          {
            MuteManager.getMutedPlayers(sender);
            return;
          }
          UUID uuid = Bukkit.getOfflinePlayer(name).getUniqueId();
          if (!MuteManager.isMuted(uuid.toString()))
          {
            sender.sendMessage("�aThe player isn't muted");
          }
          else
          {
            sender.sendMessage("�c-------------");
            sender.sendMessage("�cName: " + name);
            sender.sendMessage("�cReason: " +
              MuteManager.getReason(uuid.toString()));
            sender.sendMessage("�cTime left: " +
              MuteManager.getRemainingTime(uuid.toString()));
            sender.sendMessage("�cMuted by: " +
              MuteManager.getMuter(uuid.toString()));
            sender.sendMessage("�c-------------");
          }
        }
      }.runTaskAsynchronously(HospitalCore.getInstance());
    }
    return false;
  }
}