@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; }
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; }
@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); } } }
/** * 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); }
/** * 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); }
/** * 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); }
/** * @param message - The message config node * @return String */ public static String getMessage(String message) { return plugin.getMessage(message); }
/** * 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(); } }
/** * 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); }
/** * 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); }
/** * 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); } }
/** * 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); }
/** * 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); }
/** * 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); }
/** * 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); }
/** * 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); } } }
/** * 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); }
/** * 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); }
/** * 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); }
/** * 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); }
/** * 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); }
/** * 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); }
/** * 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); }
/** * 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); }