Beispiel #1
0
  @Override
  public void onEnable() {
    plugin = this;

    setupConfigs();
    try {
      if (!configuration.isDebugEnabled()) {
        disableDatabaseLogging();
      }

      if (!setupConnections()) {
        return;
      }

      setupStorages();
    } catch (SQLException e) {
      getLogger()
          .warning(
              "An error occurred attempting to make a database connection, please see stack trace below");
      plugin.getPluginLoader().disablePlugin(this);
      e.printStackTrace();
      return;
    }

    try {
      long timeDiff = DateUtils.findTimeDiff();

      if (timeDiff > 1) {
        getLogger()
            .severe(
                "The time on your server and MySQL database are out by "
                    + timeDiff
                    + " seconds, this may cause syncing issues.");
      }
    } catch (SQLException e) {
      getLogger()
          .warning(
              "An error occurred attempting to find the time difference, please see stack trace below");
      plugin.getPluginLoader().disablePlugin(this);
      e.printStackTrace();
    }

    if (conversionConn != null) {
      setupConversion();
    }

    setupListeners();
    setupCommands();
    setupRunnables();

    try {
      MetricsLite metrics = new MetricsLite(this);
      metrics.start();
    } catch (IOException e) {
      // Failed to submit the stats :-(
    }
  }
  public PlayerWarnStorage(ConnectionSource connection) throws SQLException {
    super(
        connection,
        (DatabaseTableConfig<PlayerWarnData>)
            BanManager.getPlugin().getConfiguration().getLocalDb().getTable("playerWarnings"));

    if (!this.isTableExists()) {
      TableUtils.createTable(connection, tableConfig);
    } else {
      // Attempt to add new columns
      try {
        String update =
            "ALTER TABLE "
                + tableConfig.getTableName()
                + " ADD COLUMN `expires` INT(10) NOT NULL DEFAULT 0,"
                + " ADD KEY `"
                + tableConfig.getTableName()
                + "_expires_idx` (`expires`)";
        executeRawNoArgs(update);
      } catch (SQLException e) {
      }
      try {
        String update =
            "ALTER TABLE "
                + tableConfig.getTableName()
                + " ADD COLUMN `points` INT(10) NOT NULL DEFAULT 1,"
                + " ADD KEY `"
                + tableConfig.getTableName()
                + "_points_idx` (`points`)";
        executeRawNoArgs(update);
      } catch (SQLException e) {

      }
    }
  }
  public boolean isRecentlyWarned(PlayerData player) throws SQLException {
    if (plugin.getConfiguration().getWarningCooldown() == 0) {
      return false;
    }

    return queryBuilder()
            .where()
            .eq("player_id", player)
            .and()
            .ge(
                "created",
                (System.currentTimeMillis() / 1000L)
                    - plugin.getConfiguration().getWarningCooldown())
            .countOf()
        > 0;
  }
  public boolean onCommand(
      CommandSender sender, Command command, String commandLabel, String args[]) {

    if (sender instanceof Player) {
      Player player = (Player) sender;

      if (!player.hasPermission("bm.reload")) {
        Util.sendMessage(player, plugin.getMessage("commandPermissionError"));
        return true;
      }
    }

    Util.sendMessage(sender, plugin.getMessage("configReloaded"));

    plugin.configReload();

    return true;
  }
Beispiel #5
0
  public boolean setupConnections() throws SQLException {
    if (!configuration.getLocalDb().isEnabled()) {
      getLogger().warning("Local Database is not enabled, disabling plugin");
      plugin.getPluginLoader().disablePlugin(this);
      return false;
    }

    localConn = setupConnection(configuration.getLocalDb());

    if (configuration.getConversionDb().isEnabled()) {
      conversionConn = setupConnection(configuration.getConversionDb());
    }

    if (configuration.getExternalDb().isEnabled()) {
      externalConn = setupConnection(configuration.getExternalDb());
    }

    return true;
  }
Beispiel #6
0
  @EventHandler
  public void onPlayerChat(final AsyncPlayerChatEvent event) {
    Player player = event.getPlayer();
    String playerName = player.getName();

    if (plugin.isPlayerMutedInMem(playerName)) {

      MuteData muteData = plugin.getPlayerMuteFromMem(playerName);
      long expires = muteData.getExpires() * 1000;
      String expiresFormat = Util.formatDateDiff(expires);

      if (muteData.getExpires() != 0) {
        if (System.currentTimeMillis() < expires) {
          event.setCancelled(true);
          String mutedMessage =
              plugin
                  .getMessage("tempMuted")
                  .replace("[expires]", expiresFormat)
                  .replace("[reason]", muteData.getReason())
                  .replace("[by]", muteData.getBy());
          player.sendMessage(mutedMessage);
        } else {
          // Removes them from the database and the HashMap
          player.sendMessage("Unmuted!");
          plugin.removePlayerMute(playerName, plugin.getMessage("consoleName"), true);
        }
      } else {
        event.setCancelled(true);
        String mutedMessage =
            plugin
                .getMessage("muted")
                .replace("[reason]", muteData.getReason())
                .replace("[by]", muteData.getBy());
        player.sendMessage(mutedMessage);
      }
    }
  }
Beispiel #7
0
 /**
  * Permanently ban a player. You must handle kicking the player if they are online.
  *
  * @param name - Name of player to ban
  * @param bannedBy - Who the ban is by, can be anything
  * @param reason - Why they are banned
  */
 public static void ban(String name, String bannedBy, String reason) {
   plugin.addPlayerBan(name, bannedBy, reason);
 }
Beispiel #8
0
 /**
  * Retrieve the players IP. This method is not thread safe and should not be called on the main
  * thread.
  *
  * @param name - Name of the player
  * @return - IP of the player, if not found an empty string is returned.
  */
 public static String getPlayerIP(String name) {
   return plugin.getPlayerIP(name);
 }
Beispiel #9
0
 /**
  * Check if a player is muted.
  *
  * <p>Due to the nature of mutes only being in memory if the player is online this method should
  * not be called within the main thread.
  *
  * @param name - Name of player to check
  * @return true if the player is currently muted, whether they are permanently muted or
  *     temporarily muted
  */
 public static boolean isMuted(String name) {
   return plugin.isPlayerMuted(name);
 }
Beispiel #10
0
 /**
  * @param message - The message config node
  * @return String
  */
 public static String getMessage(String message) {
   return plugin.getMessage(message);
 }
Beispiel #11
0
 /**
  * Retrieve past bans of a player. This method is not thread safe and should not be called on the
  * main thread.
  *
  * @param name - Name of player
  * @return ArrayList containing data on all bans
  */
 public static ArrayList<BanData> getPastBans(String name) {
   return plugin.getPlayerPastBans(name);
 }
public class PlayerWarnStorage extends BaseDaoImpl<PlayerWarnData, Integer> {

  private BanManager plugin = BanManager.getPlugin();

  public PlayerWarnStorage(ConnectionSource connection) throws SQLException {
    super(
        connection,
        (DatabaseTableConfig<PlayerWarnData>)
            BanManager.getPlugin().getConfiguration().getLocalDb().getTable("playerWarnings"));

    if (!this.isTableExists()) {
      TableUtils.createTable(connection, tableConfig);
    } else {
      // Attempt to add new columns
      try {
        String update =
            "ALTER TABLE "
                + tableConfig.getTableName()
                + " ADD COLUMN `expires` INT(10) NOT NULL DEFAULT 0,"
                + " ADD KEY `"
                + tableConfig.getTableName()
                + "_expires_idx` (`expires`)";
        executeRawNoArgs(update);
      } catch (SQLException e) {
      }
      try {
        String update =
            "ALTER TABLE "
                + tableConfig.getTableName()
                + " ADD COLUMN `points` INT(10) NOT NULL DEFAULT 1,"
                + " ADD KEY `"
                + tableConfig.getTableName()
                + "_points_idx` (`points`)";
        executeRawNoArgs(update);
      } catch (SQLException e) {

      }
    }
  }

  public boolean addWarning(PlayerWarnData data, boolean silent) throws SQLException {
    PlayerWarnEvent event = new PlayerWarnEvent(data, silent);
    Bukkit.getServer().getPluginManager().callEvent(event);

    if (event.isCancelled()) {
      return false;
    }

    boolean created = create(data) == 1;

    if (created)
      Bukkit.getServer()
          .getPluginManager()
          .callEvent(new PlayerWarnedEvent(data, event.isSilent()));

    return created;
  }

  public CloseableIterator<PlayerWarnData> getUnreadWarnings(UUID uniqueId) throws SQLException {
    return queryBuilder()
        .where()
        .eq("player_id", UUIDUtils.toBytes(uniqueId))
        .and()
        .eq("read", false)
        .iterator();
  }

  public CloseableIterator<PlayerWarnData> getWarnings(PlayerData player) throws SQLException {
    return queryBuilder().where().eq("player_id", player).iterator();
  }

  public long getCount(PlayerData player) throws SQLException {
    return queryBuilder().where().eq("player_id", player).countOf();
  }

  public long getPointsCount(PlayerData player) throws SQLException {
    return queryRawValue(
        "SELECT SUM(points) FROM "
            + getTableInfo().getTableName()
            + " WHERE player_id = UNHEX('"
            + player.getUUID().toString().replace("-", "")
            + "')");
  }

  public boolean isRecentlyWarned(PlayerData player) throws SQLException {
    if (plugin.getConfiguration().getWarningCooldown() == 0) {
      return false;
    }

    return queryBuilder()
            .where()
            .eq("player_id", player)
            .and()
            .ge(
                "created",
                (System.currentTimeMillis() / 1000L)
                    - plugin.getConfiguration().getWarningCooldown())
            .countOf()
        > 0;
  }

  public int deleteRecent(PlayerData player) throws SQLException {
    // TODO use a raw DELETE query to reduce to one query
    PlayerWarnData warning =
        queryBuilder()
            .limit(1L)
            .orderBy("created", false)
            .where()
            .eq("player_id", player)
            .queryForFirst();

    return delete(warning);
  }

  public void purge(CleanUp cleanup, boolean read) throws SQLException {
    if (cleanup.getDays() == 0) return;

    updateRaw(
        "DELETE FROM "
            + getTableInfo().getTableName()
            + " WHERE created < UNIX_TIMESTAMP(DATE_SUB(NOW(), "
            + "INTERVAL "
            + cleanup.getDays()
            + " DAY)) AND `read` = "
            + (read ? "1" : "0"));
  }

  public CloseableIterator<PlayerWarnData> findWarnings(long fromTime) throws SQLException {
    if (fromTime == 0) {
      return iterator();
    }

    long checkTime = fromTime + DateUtils.getTimeDiff();

    QueryBuilder<PlayerWarnData, Integer> query = queryBuilder();
    Where<PlayerWarnData, Integer> where = query.where();
    where.ge("created", checkTime);

    query.setWhere(where);

    return query.iterator();
  }
}
Beispiel #13
0
 /**
  * Check if a player is banned
  *
  * @param ip - IP address to check
  * @return true if the player is currently banned, whether they are permanently banned or
  *     temporarily banned
  */
 public static boolean isIPBanned(String ip) {
   return plugin.isIPBanned(ip);
 }
Beispiel #14
0
 /**
  * Check if a player is banned
  *
  * @param name - Name of player to check
  * @return true if the player is currently banned, whether they are permanently banned or
  *     temporarily banned
  */
 public static boolean isBanned(String name) {
   return plugin.isPlayerBanned(name);
 }
Beispiel #15
0
/**
 * This is a static API for BanManager. All methods are thread safe unless stated otherwise.
 *
 * <p>Note: The API does not handle the notifications to players nor permission checks for
 * exemptions.
 *
 * @author James Mortemore
 */
public class BmAPI {

  private static BanManager plugin = BanManager.getPlugin();

  // Bans
  /**
   * Permanently ban a player. You must handle kicking the player if they are online.
   *
   * @param name - Name of player to ban
   * @param bannedBy - Who the ban is by, can be anything
   * @param reason - Why they are banned
   */
  public static void ban(String name, String bannedBy, String reason) {
    plugin.addPlayerBan(name, bannedBy, reason);
  }

  /**
   * Temporarily ban a player You must handle kicking the player if they are online.
   *
   * @param name - Name of player to ban
   * @param bannedBy - Who the ban is by, can be anything
   * @param reason - Why they are banned
   * @param expires - Unix Timestamp stating the time of when the ban ends
   */
  public static void tempBan(String name, String bannedBy, String reason, long expires) {
    plugin.addPlayerBan(name, bannedBy, reason, expires);
  }

  /**
   * Unban a player
   *
   * @param name - Name of player to unban
   * @param by - Who the unban is by, can be anything
   * @param keepLog - Whether to store the ban as a record or not
   */
  public static void unBan(String name, String by, boolean keepLog) {
    plugin.removePlayerBan(name, by, keepLog);
  }

  /**
   * Check if a player is banned
   *
   * @param name - Name of player to check
   * @return true if the player is currently banned, whether they are permanently banned or
   *     temporarily banned
   */
  public static boolean isBanned(String name) {
    return plugin.isPlayerBanned(name);
  }

  /**
   * Get ban information of a player
   *
   * @param name - Name of player
   * @return - BanData object, if the player is not banned, it returns null
   */
  public static BanData getCurrentBan(String name) {
    return plugin.getPlayerBan(name);
  }

  /**
   * Retrieve past bans of a player. This method is not thread safe and should not be called on the
   * main thread.
   *
   * @param name - Name of player
   * @return ArrayList containing data on all bans
   */
  public static ArrayList<BanData> getPastBans(String name) {
    return plugin.getPlayerPastBans(name);
  }

  // Mutes
  /**
   * Permanently mute a player
   *
   * @param name - Name of player to mute
   * @param mutedBy - Who the mute is by, can be anything
   * @param reason - Why they are muted
   */
  public static void mute(String name, String mutedBy, String reason) {
    plugin.addPlayerMute(name, mutedBy, reason);
  }

  /**
   * Temporarily mute a player
   *
   * @param name - Name of player to mute
   * @param mutedBy - Who the mute is by, can be anything
   * @param reason - Why they are muted
   * @param expires - Unix Timestamp stating the time of when the ban ends
   */
  public static void tempMute(String name, String mutedBy, String reason, long expires) {
    plugin.addPlayerMute(name, mutedBy, reason, expires);
  }

  /**
   * Unmute a player
   *
   * @param name - Name of player to unmute
   * @param by - Who the unmute is by, can be anything
   * @param keepLog - Whether to store the mute as a record or not
   */
  public static void unMute(String name, String by, boolean keepLog) {
    plugin.removePlayerMute(name, by, keepLog);
  }

  /**
   * Check if a player is muted.
   *
   * <p>Due to the nature of mutes only being in memory if the player is online this method should
   * not be called within the main thread.
   *
   * @param name - Name of player to check
   * @return true if the player is currently muted, whether they are permanently muted or
   *     temporarily muted
   */
  public static boolean isMuted(String name) {
    return plugin.isPlayerMuted(name);
  }

  /**
   * Get mute information of a player.
   *
   * <p>Due to the nature of mutes only being in memory if the player is online this method should
   * not be called within the main thread.
   *
   * @param name - Name of player
   * @return - MuteData object, if the player is not banned, it returns null
   */
  public static MuteData getCurrentMute(String name) {
    return plugin.getPlayerMute(name);
  }

  /**
   * Retrieve past mutes of a player. This method is not thread safe and should not be called on the
   * main thread.
   *
   * @param name - Name of player
   * @return ArrayList containing data on all mutes
   */
  public static ArrayList<MuteData> getPastMutes(String name) {
    return plugin.getPlayerPastMutes(name);
  }

  // IP Bans
  /**
   * Permanently ban an IP You must handle kicking any players with the ip if they are online.
   *
   * @param ip - IP address to ban
   * @param bannedBy - Who the ban is by, can be anything
   * @param reason - Why they are banned
   */
  public static void banIP(String ip, String bannedBy, String reason) {
    plugin.addIPBan(ip, bannedBy, reason);
  }

  /**
   * Temporarily ban an IP You must handle kicking any players with the ip if they are online.
   *
   * @param ip - IP address to ban
   * @param bannedBy - Who the ban is by, can be anything
   * @param reason - Why they are banned
   * @param expires - Unix Timestamp stating the time of when the ban ends
   */
  public static void tempIPBan(String ip, String bannedBy, String reason, long expires) {
    plugin.addIPBan(ip, bannedBy, reason, expires);
  }

  /**
   * Unban an IP
   *
   * @param name - IP address to unban
   * @param by - Who the unban is by, can be anything
   * @param keepLog - Whether to store the ban as a record or not
   */
  public static void unBanIP(String name, String by, boolean keepLog) {
    plugin.removeIPBan(name, by, keepLog);
  }

  /**
   * Check if a player is banned
   *
   * @param ip - IP address to check
   * @return true if the player is currently banned, whether they are permanently banned or
   *     temporarily banned
   */
  public static boolean isIPBanned(String ip) {
    return plugin.isIPBanned(ip);
  }

  /**
   * Get ban information of an IP ban
   *
   * @param ip - IP address
   * @return - IPBanData object, if the IP is not banned, it returns null
   */
  public static IPBanData getCurrentIPBan(String ip) {
    return plugin.getIPBan(ip);
  }

  /**
   * Retrieve past ip bans of an IP. This method is not thread safe and should not be called on the
   * main thread.
   *
   * @param ip - IP address to check
   * @return ArrayList containing data on all bans
   */
  public static ArrayList<IPBanData> getPastIPBans(String ip) {
    return plugin.getIPPastBans(ip);
  }

  // Warnings
  /**
   * Warn a player. You must handle the notification to the warned player yourself.
   *
   * @param name - Name of player to warn
   * @param bannedBy - Who the warning is by, can be anything
   * @param reason - Why they are warned
   */
  public static void warn(String name, String warnedBy, String reason) {
    plugin.addPlayerWarning(name, warnedBy, reason);
  }

  /**
   * Retrieve past warnings of a player. This method is not thread safe and should not be called on
   * the main thread.
   *
   * @param name - Name of player
   * @return ArrayList containing data on all warnings
   */
  public static ArrayList<WarnData> getWarnings(String name) {
    return plugin.getPlayerWarnings(name);
  }

  // Kicks
  /**
   * Kicks a player and logs it to the database. You must check the player is online first otherwise
   * a NPE will be thrown.
   *
   * @param name - Name of player to kick
   * @param bannedBy - Who the kick is by, can be anything
   * @param reason - Why they are kicked
   */
  public static synchronized void kick(String name, String kickedBy, String reason) {
    String viewReason = Util.viewReason(reason);
    Player target = Bukkit.getPlayer(name);

    String kick =
        getMessage("kickReason")
            .replace("[name]", target.getDisplayName())
            .replace("[reason]", viewReason)
            .replace("[by]", kickedBy);

    target.kickPlayer(kick);

    plugin.dbLogger.logKick(name, kickedBy, reason);
  }

  // Misc
  /**
   * @param message - The message config node
   * @return String
   */
  public static String getMessage(String message) {
    return plugin.getMessage(message);
  }

  /**
   * Retrieve the players IP. This method is not thread safe and should not be called on the main
   * thread.
   *
   * @param name - Name of the player
   * @return - IP of the player, if not found an empty string is returned.
   */
  public static String getPlayerIP(String name) {
    return plugin.getPlayerIP(name);
  }
}
Beispiel #16
0
 /**
  * Temporarily ban an IP You must handle kicking any players with the ip if they are online.
  *
  * @param ip - IP address to ban
  * @param bannedBy - Who the ban is by, can be anything
  * @param reason - Why they are banned
  * @param expires - Unix Timestamp stating the time of when the ban ends
  */
 public static void tempIPBan(String ip, String bannedBy, String reason, long expires) {
   plugin.addIPBan(ip, bannedBy, reason, expires);
 }
Beispiel #17
0
 /**
  * Permanently ban an IP You must handle kicking any players with the ip if they are online.
  *
  * @param ip - IP address to ban
  * @param bannedBy - Who the ban is by, can be anything
  * @param reason - Why they are banned
  */
 public static void banIP(String ip, String bannedBy, String reason) {
   plugin.addIPBan(ip, bannedBy, reason);
 }
Beispiel #18
0
 /**
  * Retrieve past mutes of a player. This method is not thread safe and should not be called on the
  * main thread.
  *
  * @param name - Name of player
  * @return ArrayList containing data on all mutes
  */
 public static ArrayList<MuteData> getPastMutes(String name) {
   return plugin.getPlayerPastMutes(name);
 }
Beispiel #19
0
 /**
  * Get mute information of a player.
  *
  * <p>Due to the nature of mutes only being in memory if the player is online this method should
  * not be called within the main thread.
  *
  * @param name - Name of player
  * @return - MuteData object, if the player is not banned, it returns null
  */
 public static MuteData getCurrentMute(String name) {
   return plugin.getPlayerMute(name);
 }
Beispiel #20
0
 /**
  * Temporarily ban a player You must handle kicking the player if they are online.
  *
  * @param name - Name of player to ban
  * @param bannedBy - Who the ban is by, can be anything
  * @param reason - Why they are banned
  * @param expires - Unix Timestamp stating the time of when the ban ends
  */
 public static void tempBan(String name, String bannedBy, String reason, long expires) {
   plugin.addPlayerBan(name, bannedBy, reason, expires);
 }
  public WarningActionsConfig(ConfigurationSection config) {
    isEnabled = config.getBoolean("enabled", false);
    actions = new HashMap<>();

    if (!isEnabled) return;

    ConfigurationSection actionsConf = config.getConfigurationSection("actions");

    if (actionsConf == null) return;

    for (String amount : actionsConf.getKeys(false)) {
      if (!StringUtils.isNumeric(amount)) {
        plugin.getLogger().warning("Invalid warning action, " + amount + " is not numeric");
        continue;
      }

      // New check
      List<Map<?, ?>> mapList = actionsConf.getMapList(amount);
      if (mapList != null && mapList.size() != 0) {
        List<ActionCommand> actionCommands = new ArrayList<>(mapList.size());

        for (Map<?, ?> map : mapList) {
          if (map.get("cmd") == null) {
            plugin.getLogger().severe("Missing cmd from warningActions " + amount);
            continue;
          }

          long delay = 0;

          if (map.get("delay") != null) {
            try {
              delay = Long.valueOf((Integer) map.get("delay"));
            } catch (NumberFormatException e) {
              plugin.getLogger().severe("Invalid delay for " + map.get("cmd"));
              continue;
            }

            delay = delay * 20L; // Convert from seconds to ticks
          }

          actionCommands.add(new ActionCommand((String) map.get("cmd"), delay));
        }

        this.actions.put(NumberUtils.toDouble(amount), actionCommands);
      } else {
        List<String> actions = actionsConf.getStringList(amount);
        if (actions.size() == 0) continue;

        plugin
            .getLogger()
            .warning(
                "warningActions amount "
                    + amount
                    + " is using a deprecated list, please use new cmd and delay syntax");
        List<ActionCommand> actionCommands = new ArrayList<>(actions.size());

        for (String action : actions) {
          actionCommands.add(new ActionCommand(action, 0));
        }

        this.actions.put(NumberUtils.toDouble(amount), actionCommands);
      }
    }
  }
Beispiel #22
0
 /**
  * Unban a player
  *
  * @param name - Name of player to unban
  * @param by - Who the unban is by, can be anything
  * @param keepLog - Whether to store the ban as a record or not
  */
 public static void unBan(String name, String by, boolean keepLog) {
   plugin.removePlayerBan(name, by, keepLog);
 }
Beispiel #23
0
 /**
  * Retrieve past ip bans of an IP. This method is not thread safe and should not be called on the
  * main thread.
  *
  * @param ip - IP address to check
  * @return ArrayList containing data on all bans
  */
 public static ArrayList<IPBanData> getPastIPBans(String ip) {
   return plugin.getIPPastBans(ip);
 }
Beispiel #24
0
 /**
  * Get ban information of a player
  *
  * @param name - Name of player
  * @return - BanData object, if the player is not banned, it returns null
  */
 public static BanData getCurrentBan(String name) {
   return plugin.getPlayerBan(name);
 }
Beispiel #25
0
 /**
  * Warn a player. You must handle the notification to the warned player yourself.
  *
  * @param name - Name of player to warn
  * @param bannedBy - Who the warning is by, can be anything
  * @param reason - Why they are warned
  */
 public static void warn(String name, String warnedBy, String reason) {
   plugin.addPlayerWarning(name, warnedBy, reason);
 }
Beispiel #26
0
 /**
  * Permanently mute a player
  *
  * @param name - Name of player to mute
  * @param mutedBy - Who the mute is by, can be anything
  * @param reason - Why they are muted
  */
 public static void mute(String name, String mutedBy, String reason) {
   plugin.addPlayerMute(name, mutedBy, reason);
 }
Beispiel #27
0
 /**
  * Retrieve past warnings of a player. This method is not thread safe and should not be called on
  * the main thread.
  *
  * @param name - Name of player
  * @return ArrayList containing data on all warnings
  */
 public static ArrayList<WarnData> getWarnings(String name) {
   return plugin.getPlayerWarnings(name);
 }
Beispiel #28
0
 /**
  * Get ban information of an IP ban
  *
  * @param ip - IP address
  * @return - IPBanData object, if the IP is not banned, it returns null
  */
 public static IPBanData getCurrentIPBan(String ip) {
   return plugin.getIPBan(ip);
 }
Beispiel #29
0
 /**
  * Temporarily mute a player
  *
  * @param name - Name of player to mute
  * @param mutedBy - Who the mute is by, can be anything
  * @param reason - Why they are muted
  * @param expires - Unix Timestamp stating the time of when the ban ends
  */
 public static void tempMute(String name, String mutedBy, String reason, long expires) {
   plugin.addPlayerMute(name, mutedBy, reason, expires);
 }