Upstream/Plan
1
0
Fork 0
mirror of https://github.com/plan-player-analytics/Plan.git synced 2024-10-17 15:55:02 +02:00
Code Issues Projects Releases Wiki Activity

Merge branch '4.0.0-BungeeCord-Support' of https://github.com/Rsl1122/Plan-PlayerAnalytics

Browse Source 
# Conflicts:
#	Plan/src/main/java/com/djrapitops/plan/Plan.java
#	Plan/src/main/java/com/djrapitops/plan/command/commands/QuickInspectCommand.java
#	Plan/src/main/java/com/djrapitops/plan/data/handling/PlaytimeHandling.java
This commit is contained in:
Fuzzlemann 2017-08-21 19:46:51 +02:00
commit a66b4d8104
68 changed files with 541 additions and 4179 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
Plan/src/main/java/com/djrapitops/plan/Plan.java
View File

@ -30,7 +30,7 @@ import main.java.com.djrapitops.plan.command.PlanCommand;
import main.java.com.djrapitops.plan.command.commands.RegisterCommandFilter;
import main.java.com.djrapitops.plan.data.additional.HookHandler;
import main.java.com.djrapitops.plan.data.cache.AnalysisCacheHandler;
import main.java.com.djrapitops.plan.data.cache.DataCacheHandler;
import main.java.com.djrapitops.plan.data.cache.DataCache;
import main.java.com.djrapitops.plan.data.cache.InspectCacheHandler;
import main.java.com.djrapitops.plan.data.cache.PageCacheHandler;
import main.java.com.djrapitops.plan.data.listeners.*;
@ -40,6 +40,8 @@ import main.java.com.djrapitops.plan.database.databases.MySQLDB;
import main.java.com.djrapitops.plan.database.databases.SQLiteDB;
import main.java.com.djrapitops.plan.locale.Locale;
import main.java.com.djrapitops.plan.locale.Msg;
import main.java.com.djrapitops.plan.queue.processing.ProcessingQueue;
import main.java.com.djrapitops.plan.queue.processing.Processor;
import main.java.com.djrapitops.plan.ui.webserver.WebServer;
import main.java.com.djrapitops.plan.ui.webserver.api.bukkit.*;
import main.java.com.djrapitops.plan.utilities.Benchmark;
@ -67,7 +69,8 @@ public class Plan extends BukkitPlugin<Plan> {
private API api;
private DataCacheHandler handler;
private ProcessingQueue processingQueue;
private DataCache handler;
private InspectCacheHandler inspectCache;
private AnalysisCacheHandler analysisCache;
private HookHandler hookHandler; // Manages 3rd party data sources
@ -141,6 +144,8 @@ public class Plan extends BukkitPlugin<Plan> {
saveConfig();
Benchmark.stop("Enable", "Copy default config");
processingQueue = new ProcessingQueue();
Benchmark.start("Init Database");
Log.info(Locale.get(Msg.ENABLE_DB_INIT).toString());
if (Check.errorIfFalse(initDatabase(), Locale.get(Msg.ENABLE_DB_FAIL_DISABLE_INFO).toString())) {
@ -152,7 +157,7 @@ public class Plan extends BukkitPlugin<Plan> {
Benchmark.stop("Enable", "Init Database");
Benchmark.start("Init DataCache");
this.handler = new DataCacheHandler(this);
this.handler = new DataCache(this);
this.inspectCache = new InspectCacheHandler(this);
this.analysisCache = new AnalysisCacheHandler(this);
Benchmark.stop("Enable", "Init DataCache");
@ -161,9 +166,6 @@ public class Plan extends BukkitPlugin<Plan> {
registerListeners();
this.api = new API(this);
Benchmark.start("Handle Reload");
handler.handleReload();
Benchmark.stop("Enable", "Handle Reload");
Benchmark.start("Analysis refresh task registration");
// Analysis refresh settings
@ -189,7 +191,7 @@ public class Plan extends BukkitPlugin<Plan> {
}
Benchmark.start("ServerInfo Registration");
serverInfoManager = new ServerInfoManager(this);
serverInfoManager = new ServerInfoManager(this);
Benchmark.stop("Enable", "ServerInfo Registration");
setupFilter(); // TODO Move to RegisterCommand Constructor
@ -392,9 +394,9 @@ public class Plan extends BukkitPlugin<Plan> {
/**
* Used to access Cache.
*
* @return Current instance of the DataCacheHandler
* @return Current instance of the DataCache
*/
public DataCacheHandler getHandler() {
public DataCache getHandler() {
return handler;
}
@ -456,13 +458,11 @@ public class Plan extends BukkitPlugin<Plan> {
return serverVariableHolder;
}
/**
* Used to get the object storing server info
*
* @return ServerInfoManager
* @see ServerInfoManager
*/
public ServerInfoManager getServerInfoManager() {
return serverInfoManager;
public ProcessingQueue getProcessingQueue() {
return processingQueue;
}
public void addToProcessQueue(Processor processor) {
processingQueue.addToQueue(processor);
}
}

51
Plan/src/main/java/com/djrapitops/plan/api/API.java
View File

@ -95,57 +95,6 @@ public class API {
return HtmlUtils.getInspectUrlWithProtocol(name);
}
/**
* Schedule a UserData object to be fetched from the database or cache if
* the player is online.
* <p>
* The data will not be cached if it is not already cached.
*
* @param uuid UUID of the player.
* @param processor Object implementing DBCallableProcessor, which
* process (UserData data) method will be called.
*/
@Deprecated
public void scheduleForGet(UUID uuid, DBCallableProcessor processor) {
plugin.getHandler().getUserDataForProcessing(processor, uuid, false);
}
/**
* Schedule a HandlingInfo object to be processed.
* <p>
* UserData associated with the UUID of the HandlingInfo object will be
* cached.
*
* @param info object that extends HandlingInfo.
*/
@Deprecated
public void scheduleEventHandlingInfo(HandlingInfo info) {
plugin.getHandler().addToPool(info);
}
/**
* Used to cache a UserData object.
* <p>
* If data is already cached it will be overridden.
*
* @param data UserData object. Will be placed to the data.getUuid() key in
* the cache.
*/
@Deprecated
public void placeDataToCache(UserData data) {
plugin.getHandler().cache(data);
}
/**
* Used to save the cached data to the database.
* <p>
* Should be only called from an Asynchronous thread.
*/
@Deprecated
public void saveCachedData() {
plugin.getHandler().saveCachedUserData();
}
/**
* Check if the UserData is cached to the InspectCache.
*

2
Plan/src/main/java/com/djrapitops/plan/command/PlanCommand.java
View File

@ -39,9 +39,7 @@ public class PlanCommand extends TreeCommand<Plan> {
@Override
public void addCommands() {
commands.add(new InspectCommand(plugin));
commands.add(new QuickInspectCommand(plugin));
commands.add(new AnalyzeCommand(plugin));
commands.add(new QuickAnalyzeCommand(plugin));
commands.add(new SearchCommand(plugin));
commands.add(new InfoCommand(plugin));
commands.add(new ReloadCommand(plugin));

99
Plan/src/main/java/com/djrapitops/plan/command/commands/QuickAnalyzeCommand.java
View File

@ -1,99 +0,0 @@
package main.java.com.djrapitops.plan.command.commands;
import com.djrapitops.plugin.api.TimeAmount;
import com.djrapitops.plugin.command.CommandType;
import com.djrapitops.plugin.command.ISender;
import com.djrapitops.plugin.command.SubCommand;
import com.djrapitops.plugin.task.AbsRunnable;
import main.java.com.djrapitops.plan.Log;
import main.java.com.djrapitops.plan.Permissions;
import main.java.com.djrapitops.plan.Plan;
import main.java.com.djrapitops.plan.command.ConditionUtils;
import main.java.com.djrapitops.plan.data.cache.AnalysisCacheHandler;
import main.java.com.djrapitops.plan.locale.Locale;
import main.java.com.djrapitops.plan.locale.Msg;
import main.java.com.djrapitops.plan.ui.text.TextUI;
import main.java.com.djrapitops.plan.utilities.Check;
import main.java.com.djrapitops.plan.utilities.MiscUtils;
/**
* This subcommand is used to run the analysis and to view some of the data in
* game.
*
* @author Rsl1122
* @since 3.0.0
*/
@Deprecated
public class QuickAnalyzeCommand extends SubCommand {
private final Plan plugin;
private final AnalysisCacheHandler analysisCache;
/**
* Subcommand Constructor.
*
* @param plugin Current instance of Plan
*/
public QuickAnalyzeCommand(Plan plugin) {
super("qanalyze, qanalyse, qanalysis, qa",
CommandType.CONSOLE,
Permissions.QUICK_ANALYZE.getPermission(),
Locale.get(Msg.CMD_USG_QANALYZE).parse());
this.plugin = plugin;
analysisCache = plugin.getAnalysisCache();
}
@Override
public String[] addHelp() {
return Locale.get(Msg.CMD_HELP_PLAN).toArray();
}
@Override
public boolean onCommand(ISender sender, String commandLabel, String[] args) {
if (!Check.isTrue(ConditionUtils.pluginHasViewCapability(), Locale.get(Msg.CMD_FAIL_NO_DATA_VIEW).toString(), sender)) {
return true;
}
if (!Check.isTrue(analysisCache.isAnalysisEnabled(), Locale.get(Msg.CMD_INFO_ANALYSIS_TEMP_DISABLE).toString(), sender)
&& !analysisCache.isCached()) {
return true;
}
updateCache();
runMessageSenderTask(sender);
return true;
}
private void updateCache() {
if (!analysisCache.isCached() || MiscUtils.getTime() - analysisCache.getData().getRefreshDate() > TimeAmount.MINUTE.ms()) {
int bootAnID = plugin.getBootAnalysisTaskID();
if (bootAnID != -1) {
plugin.getServer().getScheduler().cancelTask(bootAnID);
}
analysisCache.updateCache();
}
}
private void runMessageSenderTask(ISender sender) {
plugin.getRunnableFactory().createNew(new AbsRunnable("QanalysisMessageSenderTask") {
private int timesRun = 0;
@Override
public void run() {
timesRun++;
if (analysisCache.isCached() && (!analysisCache.isAnalysisBeingRun() || !analysisCache.isAnalysisEnabled())) {
sender.sendMessage(Locale.get(Msg.CMD_HEADER_ANALYZE) + "");
sender.sendMessage(TextUI.getAnalysisMessages());
sender.sendMessage(Locale.get(Msg.CMD_CONSTANT_FOOTER) + "");
this.cancel();
}
if (timesRun > 10) {
Log.debug("Command Timeout Message, QuickAnalyze.");
sender.sendMessage(Locale.get(Msg.CMD_FAIL_TIMEOUT).parse("Analysis"));
this.cancel();
}
}
}).runTaskTimer(TimeAmount.SECOND.ticks(), 5 * TimeAmount.SECOND.ticks());
}
}

106
Plan/src/main/java/com/djrapitops/plan/command/commands/QuickInspectCommand.java
View File

@ -1,106 +0,0 @@
package main.java.com.djrapitops.plan.command.commands;
import com.djrapitops.plugin.api.TimeAmount;
import com.djrapitops.plugin.command.CommandType;
import com.djrapitops.plugin.command.ISender;
import com.djrapitops.plugin.command.SubCommand;
import com.djrapitops.plugin.task.AbsRunnable;
import com.djrapitops.plugin.utilities.Verify;
import main.java.com.djrapitops.plan.Log;
import main.java.com.djrapitops.plan.Permissions;
import main.java.com.djrapitops.plan.Plan;
import main.java.com.djrapitops.plan.command.ConditionUtils;
import main.java.com.djrapitops.plan.data.cache.InspectCacheHandler;
import main.java.com.djrapitops.plan.locale.Locale;
import main.java.com.djrapitops.plan.locale.Msg;
import main.java.com.djrapitops.plan.ui.text.TextUI;
import main.java.com.djrapitops.plan.utilities.Check;
import main.java.com.djrapitops.plan.utilities.MiscUtils;
import main.java.com.djrapitops.plan.utilities.uuid.UUIDUtility;
import java.util.UUID;
/**
* This command is used to cache UserData to InspectCache and to view some of
* the data in game.
*
* @author Rsl1122
* @since 3.0.0
*/
@Deprecated
public class QuickInspectCommand extends SubCommand {
private final Plan plugin;
private final InspectCacheHandler inspectCache;
/**
* Class Constructor.
*
* @param plugin Current instance of Plan
*/
public QuickInspectCommand(Plan plugin) {
super("qinspect, qi",
CommandType.CONSOLE_WITH_ARGUMENTS,
Permissions.QUICK_INSPECT.getPermission(),
Locale.get(Msg.CMD_USG_QINSPECT).toString(), "<player>");
this.plugin = plugin;
inspectCache = plugin.getInspectCache();
}
@Override
public String[] addHelp() {
return Locale.get(Msg.CMD_HELP_QINSPECT).toArray();
}
@Override
public boolean onCommand(ISender sender, String commandLabel, String[] args) {
String playerName = MiscUtils.getPlayerName(args, sender, Permissions.QUICK_INSPECT_OTHER);
plugin.getRunnableFactory().createNew(new AbsRunnable("QinspectTask") {
@Override
public void run() {
try {
UUID uuid = UUIDUtility.getUUIDOf(playerName);
if (!Check.isTrue(Verify.notNull(uuid), Locale.get(Msg.CMD_FAIL_USERNAME_NOT_VALID).toString(), sender)) {
return;
}
if (!Check.isTrue(ConditionUtils.playerHasPlayed(uuid), Locale.get(Msg.CMD_FAIL_USERNAME_NOT_SEEN).toString(), sender)) {
return;
}
if (!Check.isTrue(plugin.getDB().wasSeenBefore(uuid), Locale.get(Msg.CMD_FAIL_USERNAME_NOT_KNOWN).toString(), sender)) {
return;
}
sender.sendMessage(Locale.get(Msg.CMD_INFO_FETCH_DATA).toString());
inspectCache.cache(uuid);
runMessageSenderTask(uuid, sender, playerName);
} finally {
this.cancel();
}
}
}).runTaskAsynchronously();
return true;
}
private void runMessageSenderTask(UUID uuid, ISender sender, String playerName) {
plugin.getRunnableFactory().createNew(new AbsRunnable("QinspectMessageSenderTask") {
private int timesrun = 0;
@Override
public void run() {
timesrun++;
if (inspectCache.isCached(uuid)) {
sender.sendMessage(Locale.get(Msg.CMD_HEADER_INSPECT) + " " + playerName);
sender.sendMessage(TextUI.getInspectMessages(uuid));
sender.sendMessage(Locale.get(Msg.CMD_CONSTANT_FOOTER).toString());
this.cancel();
}
if (timesrun > 10) {
Log.debug("Command Timeout Message, QuickInspect.");
sender.sendMessage(Locale.get(Msg.CMD_FAIL_TIMEOUT).parse("Qinspect"));
this.cancel();
}
}
}).runTaskTimer(TimeAmount.SECOND.ticks(), 5 * TimeAmount.SECOND.ticks());
}
}

2
Plan/src/main/java/com/djrapitops/plan/command/commands/manage/ManageClearCommand.java
View File

@ -82,7 +82,7 @@ public class ManageClearCommand extends SubCommand {
sender.sendMessage(Locale.get(Msg.MANAGE_INFO_START).parse());
if (database.removeAllData()) {
plugin.getHandler().getDataCache().clear();
// TODO Clear active session of all users & start new ones
sender.sendMessage(Locale.get(Msg.MANAGE_INFO_CLEAR_SUCCESS).toString());
} else {
sender.sendMessage(Locale.get(Msg.MANAGE_INFO_FAIL).toString());

58
Plan/src/main/java/com/djrapitops/plan/command/commands/manage/ManageImportCommand.java
View File

@ -3,23 +3,12 @@ package main.java.com.djrapitops.plan.command.commands.manage;
import com.djrapitops.plugin.command.CommandType;
import com.djrapitops.plugin.command.ISender;
import com.djrapitops.plugin.command.SubCommand;
import com.djrapitops.plugin.task.AbsRunnable;
import com.djrapitops.plugin.utilities.FormattingUtils;
import com.djrapitops.plugin.utilities.player.Fetch;
import com.djrapitops.plugin.utilities.player.IOfflinePlayer;
import main.java.com.djrapitops.plan.Permissions;
import main.java.com.djrapitops.plan.Plan;
import main.java.com.djrapitops.plan.data.handling.importing.ImportUtils;
import main.java.com.djrapitops.plan.data.handling.importing.Importer;
import main.java.com.djrapitops.plan.locale.Locale;
import main.java.com.djrapitops.plan.locale.Msg;
import main.java.com.djrapitops.plan.utilities.Check;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.stream.Collectors;
/**
* This manage subcommand is used to import data from 3rd party plugins.
* <p>
@ -58,52 +47,7 @@ public class ManageImportCommand extends SubCommand {
if (!Check.isTrue(args.length >= 1, Locale.get(Msg.CMD_FAIL_REQ_ONE_ARG) + " " + this.getArguments(), sender)) {
return true;
}
String importFromPlugin = args[0].toLowerCase();
Map<String, Importer> importPlugins = ImportUtils.getImporters();
if (importFromPlugin.equals("list")) {
list(importPlugins, sender);
return true;
}
if (!Check.isTrue(importPlugins.keySet().contains(importFromPlugin), Locale.get(Msg.MANAGE_FAIL_INCORRECT_PLUGIN) + importFromPlugin, sender)) {
return true;
}
if (!Check.isTrue(ImportUtils.isPluginEnabled(importFromPlugin), Locale.get(Msg.MANAGE_FAIL_PLUGIN_NOT_ENABLED) + importFromPlugin, sender)) {
return true;
}
String[] importArguments = FormattingUtils.removeFirstArgument(args);
final Importer importer = importPlugins.get(importFromPlugin);
runImportTask(sender, importer, importArguments);
// TODO Rewrite Importer
return true;
}
private void runImportTask(ISender sender, final Importer importer, String... importArguments) {
plugin.getRunnableFactory().createNew(new AbsRunnable("ImportTask") {
@Override
public void run() {
try {
sender.sendMessage(Locale.get(Msg.MANAGE_INFO_IMPORT).toString());
List<UUID> uuids = Fetch.getIOfflinePlayers().stream().map(IOfflinePlayer::getUniqueId).collect(Collectors.toList());
if (importer.importData(uuids, importArguments)) {
sender.sendMessage(Locale.get(Msg.MANAGE_INFO_SUCCESS).toString());
} else {
sender.sendMessage(Locale.get(Msg.MANAGE_INFO_FAIL).toString());
}
} finally {
this.cancel();
}
}
}).runTaskAsynchronously();
}
private void list(Map<String, Importer> importers, ISender sender) {
sender.sendMessage(Locale.get(Msg.CMD_CONSTANT_FOOTER).parse());
importers.forEach((string, importer) -> sender.sendMessage(Locale.get(Msg.CMD_CONSTANT_LIST_BALL) + " " + string + ": " + importer.getInfo()));
sender.sendMessage(Locale.get(Msg.CMD_CONSTANT_FOOTER).parse());
}
}

2
Plan/src/main/java/com/djrapitops/plan/command/commands/manage/ManageRemoveCommand.java
View File

@ -84,7 +84,7 @@ public class ManageRemoveCommand extends SubCommand {
sender.sendMessage(Locale.get(Msg.MANAGE_INFO_START).parse());
try {
plugin.getHandler().getDataCache().remove(uuid);
// TODO Clear active session of user & start new one
if (plugin.getDB().removeAccount(uuid.toString())) {
sender.sendMessage(Locale.get(Msg.MANAGE_INFO_REMOVE_SUCCESS).parse(playerName, plugin.getDB().getConfigName()));
} else {

66
Plan/src/main/java/com/djrapitops/plan/data/SessionData.java
View File

@ -2,6 +2,9 @@ package main.java.com.djrapitops.plan.data;
import main.java.com.djrapitops.plan.data.time.WorldTimes;
import java.util.ArrayList;
import java.util.List;
/**
* This class is used for storing start and end of a play session inside UserData
* object.
@ -10,40 +13,48 @@ import main.java.com.djrapitops.plan.data.time.WorldTimes;
*/
public class SessionData {
private WorldTimes worldTimes; // TODO add World Times to SessionData
private final WorldTimes worldTimes; // TODO add World Times to SessionData
private final long sessionStart;
private long sessionEnd;
// TODO Add kills & deaths to SessionData
private final List<KillData> playerKills;
private int mobKills;
private int deaths;
@Deprecated // TODO Remove
public SessionData(long sessionStart) {
worldTimes = null;
this.sessionStart = 0;
playerKills = null;
}
/**
* Creates a new session with given start and end of -1.
*
* @param sessionStart Epoch millisecond the session was started.
*/
public SessionData(long sessionStart) {
public SessionData(long sessionStart, String world, String gm) {
this.worldTimes = new WorldTimes(world, gm);
this.sessionStart = sessionStart;
this.sessionEnd = -1;
playerKills = new ArrayList<>();
mobKills = 0;
deaths = 0;
}
/**
* Creates a new session with given start and end.
* Re-Creates a session data object for viewing.
*
* @param sessionStart Epoch millisecond the session was started.
* @param sessionEnd Epoch millisecond the session ended.
*/
public SessionData(long sessionStart, long sessionEnd) {
public SessionData(long sessionStart, long sessionEnd, WorldTimes worldTimes, List<KillData> playerKills, int mobKills, int deaths) {
this.sessionStart = sessionStart;
this.sessionEnd = sessionEnd;
}
/**
* Constructor for copying the object.
*
* @param s SessionData to copy.
*/
public SessionData(SessionData s) {
this.sessionStart = s.getSessionStart();
this.sessionEnd = s.getSessionEnd();
this.worldTimes = worldTimes;
this.playerKills = playerKills;
this.mobKills = mobKills;
this.deaths = deaths;
}
/**
@ -55,6 +66,16 @@ public class SessionData {
*/
public void endSession(long endOfSession) {
sessionEnd = endOfSession;
worldTimes.updateState(endOfSession);
}
/**
* Get the length of the session in milliseconds.
*
* @return Long in ms.
*/
public long getLength() {
return sessionEnd - sessionStart;
}
/**
@ -75,25 +96,12 @@ public class SessionData {
return sessionEnd;
}
/**
* Get the length of the session in milliseconds.
*
* @return Long in ms.
*/
public long getLength() {
return sessionEnd - sessionStart;
}
@Override
public String toString() {
return "s:" + sessionStart + " e:" + sessionEnd;
}
/**
* Check if the session start was before the end.
*
* @return Is the length positive?
*/
@Deprecated // TODO Remove
public boolean isValid() {
return sessionStart <= sessionEnd;
}

604
Plan/src/main/java/com/djrapitops/plan/data/UserData.java
View File

@ -1,15 +1,7 @@
package main.java.com.djrapitops.plan.data;
import com.djrapitops.plugin.utilities.Verify;
import com.djrapitops.plugin.utilities.player.IOfflinePlayer;
import com.djrapitops.plugin.utilities.player.IPlayer;
import main.java.com.djrapitops.plan.Log;
import main.java.com.djrapitops.plan.data.time.GMTimes;
import main.java.com.djrapitops.plan.data.time.WorldTimes;
import java.net.InetAddress;
import java.util.*;
import java.util.stream.Collectors;
/**
* This class is used for storing information about a player during runtime.
@ -24,23 +16,26 @@ public class UserData {
private boolean clearAfterSave;
private UUID uuid;
private String name; //TODO DB Update code to JoinListener
@Deprecated private Set<String> nicknames; //TODO DB Update code to ChatListener
@Deprecated private String lastNick; //TODO DB Update code to ChatListener
@Deprecated private String geolocation; //TODO DB Update code to JoinListener
@Deprecated private Set<InetAddress> ips; //TODO DB Update code to JoinListener
@Deprecated private int loginTimes; // Moving to sessions.size
@Deprecated private int timesKicked; //TODO DB Update code to KickListener
@Deprecated private boolean isOp; //TODO DB Update code to JoinListener
@Deprecated private boolean isBanned; //TODO DB Update code to JoinListener
@Deprecated private boolean isOnline; //TODO New Class for getting online status of players
@Deprecated private int mobKills; //TODO Move to SessionData
@Deprecated private List<KillData> playerKills; //TODO Move to SessionData
@Deprecated private int deaths; //TODO Move to SessionData
@Deprecated private long registered; //TODO DB Update code to JoinListener (When registering)
@Deprecated private long lastPlayed; //TODO DB Update code to Join, Refresh, QuitListener
@Deprecated private long playTime; //TODO Move to SessionData
@Deprecated private GMTimes gmTimes; //TODO Move to WorldTimes
@Deprecated private WorldTimes worldTimes; //TODO Move to SessionData
@Deprecated
private Set<String> nicknames; //TODO DB Update code to ChatListener
@Deprecated
private String lastNick; //TODO DB Update code to ChatListener
@Deprecated
private String geolocation; //TODO DB Update code to JoinListener
@Deprecated
private Set<InetAddress> ips; //TODO DB Update code to JoinListener
@Deprecated
private int timesKicked; //TODO DB Update code to KickListener
@Deprecated
private boolean isOp; //TODO DB Update code to JoinListener
@Deprecated
private boolean isBanned; //TODO DB Update code to JoinListener
@Deprecated
private boolean isOnline; //TODO New Class for getting online status of players
@Deprecated
private long registered; //TODO DB Update code to JoinListener (When registering)
@Deprecated
private long lastPlayed; //TODO DB Update code to Join, Refresh, QuitListener
/**
* Creates a new UserData object with given values and default values.
@ -58,88 +53,12 @@ public class UserData {
* worldTimes Map is left empty.
*
* @param uuid UUID of the player
* @param reg Epoch millisecond the player registered.
* @param op Is the player op? (true/false)
* @param name Name of the player.
* @param online Is the player online?
*/
public UserData(UUID uuid, long reg, boolean op, String gm, String name, boolean online) {
accessing = 0;
this.gmTimes = new GMTimes(gm);
// TODO REMOVE this.worldTimes = new WorldTimes();
public UserData(UUID uuid, String name) {
this.uuid = uuid;
this.name = name;
lastNick = "";
nicknames = new HashSet<>();
ips = new HashSet<>();
geolocation = "Not Known";
isOp = op;
isOnline = online;
registered = reg;
sessions = new ArrayList<>();
playerKills = new ArrayList<>();
}
/**
* Creates a new UserData object with the variables inside a Player object.
* <p>
* Some variables are left uninitialized: lastPlayed, playTime, loginTimes,
* timesKicked, lastGmSwapTime, mobKills, deaths and currentSession.
* <p>
* These variables need to be set with setters.
* <p>
* All Collections are left empty: locations, nicknames, ips, sessions,
* playerKills. Because nicknames is empty, lastNick is an empty string.
* <p>
* gmTimes HashMap will contain 4 '0L' values: SURVIVAL, CREATIVE,
* ADVENTURE, SPECTATOR
*
* @param player IPlayer object.
*/
public UserData(IPlayer player) {
this(player.getUuid(), player.getFirstPlayed(), player.isOp(), player.getGamemode().name(), player.getName(), player.isOnline());
try {
isBanned = player.isBanned();
} catch (Exception e) {
Log.error("Error getting ban date from Bukkit files. " + uuid.toString());
Log.toLog(this.getClass().getName(), e);
isBanned = false;
}
}
/**
* Creates a new UserData object with the variables inside a OfflinePlayer
* object.
* <p>
* Some variables are left uninitialized: location, lastPlayed, playTime,
* loginTimes, timesKicked, lastGmSwapTime, mobKills, deaths and
* currentSession.
* <p>
* These variables need to be set with setters.
* <p>
* All Collections are left empty: locations, nicknames, ips, sessions,
* playerKills. Because nicknames is empty, lastNick is an empty string.
* <p>
* gmTimes HashMap will contain 4 '0L' values: SURVIVAL, CREATIVE,
* ADVENTURE, SPECTATOR
* <p>
* lastGM will be set as SURVIVAL
*
* @param player IOfflinePlayer object.
*/
public UserData(IOfflinePlayer player) {
this(player.getUniqueId(), player.getFirstPlayed(), player.isOp(), "SURVIVAL", player.getName(), player.isOnline());
try {
isBanned = player.isBanned();
} catch (Exception e) {
Log.error("Error getting ban date from Bukkit files. " + uuid.toString());
Log.toLog(this.getClass().getName(), e);
isBanned = false;
}
}
/**
@ -148,159 +67,12 @@ public class UserData {
* @param data UserData to copy into the new object.
*/
public UserData(UserData data) {
this.accessing = 0;
this.uuid = data.getUuid();
this.ips = new HashSet<>();
ips.addAll(data.getIps());
this.nicknames = new HashSet<>();
nicknames.addAll(data.getNicknames());
this.lastNick = data.getLastNick();
this.registered = data.getRegistered();
this.lastPlayed = data.getLastPlayed();
this.playTime = data.getPlayTime();
this.loginTimes = data.getLoginTimes();
this.timesKicked = data.getTimesKicked();
this.gmTimes = data.getGmTimes();
this.worldTimes = data.getWorldTimes();
this.isOp = data.isOp();
this.isBanned = data.isBanned();
this.geolocation = data.getGeolocation();
this.mobKills = data.getMobKills();
this.playerKills = data.getPlayerKills();
this.deaths = data.getDeaths();
this.name = data.getName();
this.isOnline = data.isOnline();
this.sessions = new ArrayList<>();
sessions.addAll(data.getSessions());
}
@Override
public String toString() {
try {
return "{" + "accessing:" + accessing + "|uuid:" + uuid + "|ips:" + ips + "|nicknames:" + nicknames + "|lastNick:" + lastNick + "|registered:" + registered + "|lastPlayed:" + lastPlayed + "|playTime:" + playTime + "|loginTimes:" + loginTimes + "|timesKicked:" + timesKicked + "|gm:" + gmTimes + "|world:" + worldTimes + "|isOp:" + isOp + "|isBanned:" + isBanned + "|geolocation:" + geolocation + "|mobKills:" + mobKills + "|playerKills:" + playerKills + "|deaths:" + deaths + "|name:" + name + "|isOnline:" + isOnline + "|sessions:" + sessions + '}';
} catch (Exception e) {
return "UserData: Error on toString:" + e;
}
}
/**
* Adds an to the ips Set if it is not null or the set doesn't contain it.
*
* @param ip InetAddress of the player.
*/
public void addIpAddress(InetAddress ip) {
if (Verify.notNull(ip)) {
ips.add(ip);
}
}
/**
* Adds multiple ips to the ips set if they're not null.
*
* @param addIps a Collection of InetAddresses the player has logged from.
*/
public void addIpAddresses(Collection<InetAddress> addIps) {
if (addIps.isEmpty()) {
return;
}
ips.addAll(addIps.stream().filter(Verify::notNull).collect(Collectors.toList()));
}
/**
* Adds a nickname to the nicknames Set.
* <p>
* null or empty values filtered.
* <p>
* lastNick will be set as the given parameter, if accepted.
*
* @param nick Displayname of the player.
* @return was lastNick updated?
*/
public boolean addNickname(String nick) {
if (!Verify.isEmpty(nick)) {
boolean isNew = !nicknames.contains(nick);
nicknames.add(nick);
if (isNew) {
lastNick = nick;
}
return isNew;
}
return false;
}
/**
* Adds nicknames to the nicknames Set.
* <p>
* null or empty values filtered.
*
* @param addNicks Collection of nicknames.
*/
public void addNicknames(Collection<String> addNicks) {
nicknames.addAll(addNicks.stream().filter(nick -> !Verify.isEmpty(nick)).collect(Collectors.toList()));
}
/**
* Adds a new SessionData to the sessions list.
* <p>
* null and invalid sessions filtered.
*
* @param session SessionData object
*/
public void addSession(SessionData session) {
if (Verify.notNull(session) && session.isValid()) {
sessions.add(session);
}
}
/**
* Adds SessionData objects to the sessions list.
* <p>
* null and invalid sessions filtered.
*
* @param sessions Collection of SessionData objects.
*/
public void addSessions(Collection<SessionData> sessions) {
Collection<SessionData> filteredSessions = sessions.stream()
.filter(Verify::notNull)
.filter(SessionData::isValid)
.collect(Collectors.toList());
this.sessions.addAll(filteredSessions);
}
/**
* Changes the value of isBanned.
*
* @param isBanned Is the player banned?
*/
public void updateBanned(boolean isBanned) {
this.isBanned = isBanned;
}
/**
* Checks whether or not the UserData object is accessed by different save
* processes.
*
* @return true if accessed.
*/
public boolean isAccessed() {
return accessing > 0;
}
/**
* Accesses the UserData object to protect it from being cleared.
*/
public void access() {
accessing++;
}
/**
* Stops accessing the object so that it can now be cleared.
*/
public void stopAccessing() {
accessing--;
}
/**
* Used to get the UUID of the player.
*
@ -310,15 +82,6 @@ public class UserData {
return uuid;
}
/**
* Set the UUID.
*
* @param uuid UUID
*/
public void setUuid(UUID uuid) {
this.uuid = uuid;
}
/**
* Get the InetAddress Set.
*
@ -328,17 +91,6 @@ public class UserData {
return ips;
}
/**
* Set the ips set.
*
* @param ips ips of the user.
*/
public void setIps(Set<InetAddress> ips) {
if (Verify.notNull(ips)) {
this.ips = ips;
}
}
/**
* Get the nickname String Set.
*
@ -348,17 +100,6 @@ public class UserData {
return nicknames;
}
/**
* Set the nicknames set.
*
* @param nicknames nicknames of the user.
*/
public void setNicknames(Set<String> nicknames) {
if (Verify.notNull(nicknames)) {
this.nicknames = nicknames;
}
}
/**
* Get the Epoch millisecond the player registered.
*
@ -368,15 +109,6 @@ public class UserData {
return registered;
}
/**
* Set the time the user was registered.
*
* @param registered Epoch millisecond of register time.
*/
public void setRegistered(long registered) {
this.registered = registered;
}
/**
* Get the Epoch millisecond the player was last seen.
* <p>
@ -389,39 +121,6 @@ public class UserData {
return lastPlayed;
}
/**
* Set the time the user was last seen.
* <p>
* Affects playtime calculation, playtime should be updated before updating
* this value.
*
* @param lastPlayed Epoch millisecond of last seen moment.
*/
public void setLastPlayed(long lastPlayed) {
this.lastPlayed = lastPlayed;
}
/**
* Get the playtime in milliseconds.
* <p>
* NOT INITIALIZED BY CONSTRUCTORS. Value is updated periodically by cache
* if the player is online.
*
* @return time in ms.
*/
public long getPlayTime() {
return playTime;
}
/**
* Set the time the user has been playing.
*
* @param playTime Time in ms.
*/
public void setPlayTime(long playTime) {
this.playTime = playTime;
}
/**
* Get how many times the player has logged in.
* <p>
@ -430,18 +129,7 @@ public class UserData {
* @return 0 to Integer.MAX
*/
public int getLoginTimes() {
return loginTimes;
}
/**
* Set how many times the user has logged in.
* <p>
* No check for input.
*
* @param loginTimes 0 to Int.MAX
*/
public void setLoginTimes(int loginTimes) {
this.loginTimes = loginTimes;
return sessions.size();
}
/**
@ -455,45 +143,6 @@ public class UserData {
return timesKicked;
}
/**
* Set how many times the user has been kicked.
* <p>
* No check for input.
*
* @param timesKicked 0 to Int.MAX
*/
public void setTimesKicked(int timesKicked) {
this.timesKicked = timesKicked;
}
/**
* Get the GMTimes object.
*
* @return TimeKeeper object with possible keys of SURVIVAL, CREATIVE, ADVENTURE, SPECTATOR
*/
public GMTimes getGmTimes() {
return gmTimes;
}
/**
* Set the GM Times object containing playtime in each gamemode.
*
* @param gmTimes GM Times object
*/
public void setGmTimes(GMTimes gmTimes) {
if (Verify.notNull(gmTimes)) {
this.gmTimes = gmTimes;
}
}
public void setGmTimes(Map<String, Long> times) {
if (Verify.notNull(times)) {
for (Map.Entry<String, Long> entry : times.entrySet()) {
gmTimes.setTime(entry.getKey(), entry.getValue());
}
}
}
/**
* Is the user Operator?
*
@ -512,15 +161,6 @@ public class UserData {
return isBanned;
}
/**
* Set the banned value.
*
* @param isBanned true/false
*/
public void setBanned(boolean isBanned) {
this.isBanned = isBanned;
}
/**
* Get the username of the player.
*
@ -530,107 +170,6 @@ public class UserData {
return name;
}
/**
* Set the username of the user.
*
* @param name username.
*/
public void setName(String name) {
this.name = name;
}
/**
* Set whether or not player is op.
*
* @param isOp operator?
*/
public void setIsOp(boolean isOp) {
this.isOp = isOp;
}
/**
* Is the player online?
*
* @return true if data is cached to datacache, false if not.
*/
public boolean isOnline() {
return isOnline;
}
/**
* Set the online value.
*
* @param isOnline true/false
*/
public void setOnline(boolean isOnline) {
this.isOnline = isOnline;
}
/**
* Get how many mob kills the player has.
*
* @return 0 to Int.MAX
*/
public int getMobKills() {
return mobKills;
}
/**
* Get how many mob kills the player has.
*
* @param mobKills 0 to Int.MAX
*/
public void setMobKills(int mobKills) {
this.mobKills = mobKills;
}
/**
* Get the player kills list.
*
* @return playerkills list.
*/
public List<KillData> getPlayerKills() {
return playerKills;
}
/**
* Set the playerkills list.
*
* @param playerKills list of players kills.
*/
public void setPlayerKills(List<KillData> playerKills) {
if (Verify.notNull(playerKills)) {
this.playerKills = playerKills;
}
}
/**
* Add a Killdata to player's kills list.
*
* @param kill KillData representing a player kill.
*/
public void addPlayerKill(KillData kill) {
playerKills.add(kill);
}
/**
* Get how many times the player has died.
*
* @return 0 to Int.MAX
*/
public int getDeaths() {
return deaths;
}
/**
* Set how many times the player has died.
*
* @param deaths 0 to Int.MAX
*/
public void setDeaths(int deaths) {
this.deaths = deaths;
}
/**
* Get the sessions of a player.
*
@ -640,89 +179,13 @@ public class UserData {
return sessions;
}
/**
* Get the last nickname the user has set.
* <p>
* Set when using addNickname(String)
*
* @return last nickname used.
*/
public String getLastNick() {
return lastNick;
}
/**
* Set the last nickname the user has set.
* <p>
* Also set when using addNickname(String)
*
* @param lastNick last nickname used.
*/
public void setLastNick(String lastNick) {
this.lastNick = lastNick;
}
public WorldTimes getWorldTimes() {
return worldTimes;
}
public void setWorldTimes(WorldTimes worldTimes) {
this.worldTimes = worldTimes;
}
/**
* Check whether or not the object should be cleared from cache after it has
* been saved.
*
* @return true/false
*/
public boolean shouldClearAfterSave() {
return clearAfterSave;
}
/**
* Set whether or not the object should be cleared from cache after it has
* been saved.
*
* @param clearAfterSave true/false
*/
public void setClearAfterSave(boolean clearAfterSave) {
this.clearAfterSave = clearAfterSave;
}
public String getGeolocation() {
return geolocation;
}
public void setGeolocation(String geolocation) {
this.geolocation = geolocation;
}
@Override
public int hashCode() {
int result = sessions.hashCode();
result = 31 * result + accessing;
result = 31 * result + (clearAfterSave ? 1 : 0);
result = 31 * result + uuid.hashCode();
result = 31 * result + ips.hashCode();
result = 31 * result + nicknames.hashCode();
result = 31 * result + lastNick.hashCode();
result = 31 * result + (int) (registered ^ (registered >>> 32));
result = 31 * result + (int) (lastPlayed ^ (lastPlayed >>> 32));
result = 31 * result + (int) (playTime ^ (playTime >>> 32));
result = 31 * result + loginTimes;
result = 31 * result + timesKicked;
result = 31 * result + gmTimes.hashCode();
result = 31 * result + worldTimes.hashCode();
result = 31 * result + (isOp ? 1 : 0);
result = 31 * result + (isBanned ? 1 : 0);
result = 31 * result + geolocation.hashCode();
result = 31 * result + mobKills;
result = 31 * result + playerKills.hashCode();
result = 31 * result + deaths;
result = 31 * result + name.hashCode();
result = 31 * result + (isOnline ? 1 : 0);
return result;
}
@ -740,20 +203,17 @@ public class UserData {
final UserData other = (UserData) obj;
return this.registered == other.registered
&& this.playTime == other.playTime
&& this.loginTimes == other.loginTimes
&& this.timesKicked == other.timesKicked
&& this.mobKills == other.mobKills
&& this.deaths == other.deaths
&& Objects.equals(this.lastNick, other.lastNick)
&& Objects.equals(this.name, other.name)
return Objects.equals(this.name, other.name)
&& Objects.equals(this.uuid, other.uuid)
&& Objects.equals(this.ips, other.ips)
&& Objects.equals(this.nicknames, other.nicknames)
&& Objects.equals(this.gmTimes, other.gmTimes)
&& Objects.equals(this.worldTimes, other.worldTimes)
&& Objects.equals(this.playerKills, other.playerKills)
&& Objects.equals(this.sessions, other.sessions);
}
public long getPlayTime() {
return 0; //TODO Use Sessions
}
public List<String> getGeolocations() {
// TODO
return null;
}
}

3
Plan/src/main/java/com/djrapitops/plan/data/analysis/ActivityPart.java
View File

@ -4,7 +4,6 @@ import com.djrapitops.plugin.api.TimeAmount;
import com.djrapitops.plugin.utilities.Verify;
import main.java.com.djrapitops.plan.data.SessionData;
import main.java.com.djrapitops.plan.data.TPS;
import main.java.com.djrapitops.plan.ui.html.RecentPlayersButtonsCreator;
import main.java.com.djrapitops.plan.ui.html.graphs.PlayerActivityGraphCreator;
import main.java.com.djrapitops.plan.ui.html.graphs.PunchCardGraphCreator;
import main.java.com.djrapitops.plan.ui.html.graphs.SessionLengthDistributionGraphCreator;
@ -67,7 +66,7 @@ public class ActivityPart extends RawData {
Verify.nullCheck(recentPlayersUUIDs);
// TODO Recent logins table
addValue("recentlogins", RecentPlayersButtonsCreator.createRecentLoginsButtons(recentPlayers, 15));
addValue("recentlogins", "");
activityPiechart();

232
Plan/src/main/java/com/djrapitops/plan/data/cache/DataCache.java vendored Normal file
View File

@ -0,0 +1,232 @@
package main.java.com.djrapitops.plan.data.cache;
import com.djrapitops.plugin.task.AbsRunnable;
import com.djrapitops.plugin.utilities.player.IPlayer;
import main.java.com.djrapitops.plan.Log;
import main.java.com.djrapitops.plan.Plan;
import main.java.com.djrapitops.plan.data.TPS;
import main.java.com.djrapitops.plan.database.Database;
import main.java.com.djrapitops.plan.locale.Locale;
import main.java.com.djrapitops.plan.locale.Msg;
import main.java.com.djrapitops.plan.queue.processing.Processor;
import main.java.com.djrapitops.plan.utilities.Benchmark;
import main.java.com.djrapitops.plan.utilities.MiscUtils;
import main.java.com.djrapitops.plan.utilities.analysis.MathUtils;
import org.bukkit.entity.Player;
import java.sql.SQLException;
import java.util.*;
/**
* This Class contains the Cache.
* <p>
* It is used to store command use, active sessions and Unsaved TPS objects
* objects in memory.
* <p>
* Its methods can be used to access all the data it stores and to clear them.
*
* @author Rsl1122
* @since 2.0.0
*/
public class DataCache extends SessionCache {
// Plan
private final Plan plugin;
private final Database db;
//Cache
private Map<String, Integer> commandUse;
private List<List<TPS>> unsavedTPSHistory;
// Queues
// Variables
private boolean periodicTaskIsSaving = false;
/**
* Class Constructor.
* <p>
* Gets the Database from the plugin. Starts the queues. Registers
* Asynchronous Periodic Save Task
*
* @param plugin Current instance of Plan
*/
public DataCache(Plan plugin) {
super(); // Initializes Session & Location cache.
this.plugin = plugin;
db = plugin.getDB();
commandUse = new HashMap<>();
if (!getCommandUseFromDb()) {
Log.error(Locale.get(Msg.ENABLE_DB_FAIL_DISABLE_INFO).toString());
plugin.disablePlugin();
return;
}
unsavedTPSHistory = new ArrayList<>();
startAsyncPeriodicSaveTask();
}
/**
* Used to get the initial commandUse Map from the database.
*
* @return Was the fetch successful?
*/
public boolean getCommandUseFromDb() {
try {
commandUse = db.getCommandUse();
return true;
} catch (Exception e) {
Log.toLog(this.getClass().getName(), e);
}
return false;
}
/**
* Used to start the Asynchronous Save Task.
*
* @throws IllegalArgumentException BukkitRunnable was given wrong
* parameters.
* @throws IllegalStateException BukkitScheduler is in a wrong state.
*/
public void startAsyncPeriodicSaveTask() {
DataCache handler = this;
plugin.getRunnableFactory().createNew(new AbsRunnable("PeriodicCacheSaveTask") {
private int timesSaved = 0;
@Override
public void run() {
if (periodicTaskIsSaving) {
return;
}
try {
periodicTaskIsSaving = true;
Log.debug("Database", "Periodic Cache Save");
saveCommandUse();
saveUnsavedTPSHistory();
timesSaved++;
} catch (Exception e) {
Log.toLog(this.getClass().getName() + "(" + this.getName() + ")", e);
} finally {
periodicTaskIsSaving = false;
}
}
}).runTaskTimerAsynchronously(60L * 20L * 5, 60L * 20L * 5);
}
/**
* Saves all data in the cache to Database and closes the database down.
* <p>
* Stops all tasks.
* <p>
* If processingQueue has unprocessed information, it will be processed.
*/
@Deprecated
public void saveCacheOnDisable() { // TODO Rewrite
long time = MiscUtils.getTime();
Benchmark.start("Cache: SaveOnDisable");
Benchmark.start("Cache: ProcessOnlineHandlingInfo");
List<IPlayer> onlinePlayers = plugin.fetch().getOnlinePlayers();
Log.debug("Online: " + onlinePlayers.size());
for (IPlayer p : onlinePlayers) {
UUID uuid = p.getUuid();
endSession(uuid);
String worldName = ((Player) p.getWrappedPlayerClass()).getWorld().getName();
}
// toProcess.sort(new HandlingInfoTimeComparator());
Benchmark.stop("Cache: ProcessOnlineHandlingInfo");
try {
db.saveCommandUse(commandUse);
} catch (SQLException e) {
Log.toLog(this.getClass().getName(), e);
}
saveUnsavedTPSHistory();
try {
db.close();
} catch (SQLException e) {
Log.toLog(this.getClass().getName(), e);
}
Benchmark.stop("Cache: SaveOnDisable");
}
private void processUnprocessedHandlingInfo(List<Processor> toProcess) {
Log.debug("PROCESS: " + toProcess.size());
for (Processor i : toProcess) {
i.process();
}
}
/**
* Saves the cached CommandUse.
* <p>
* Should be only called from an Asynchronous Thread.
*/
public void saveCommandUse() {
try {
db.saveCommandUse(new HashMap<>(commandUse));
} catch (SQLException | NullPointerException e) {
Log.toLog(this.getClass().getName(), e);
}
}
public void saveUnsavedTPSHistory() {
List<TPS> averages = calculateAverageTpsForEachMinute();
if (averages.isEmpty()) {
return;
}
try {
Log.debug("Database", "Periodic TPS Save: " + averages.size());
db.getTpsTable().saveTPSData(averages);
} catch (SQLException ex) {
Log.toLog(this.getClass().getName(), ex);
}
}
private List<TPS> calculateAverageTpsForEachMinute() {
final List<TPS> averages = new ArrayList<>();
if (unsavedTPSHistory.isEmpty()) {
return new ArrayList<>();
}
List<List<TPS>> copy = new ArrayList<>(unsavedTPSHistory);
for (List<TPS> history : copy) {
final long lastDate = history.get(history.size() - 1).getDate();
final double averageTPS = MathUtils.round(MathUtils.averageDouble(history.stream().map(TPS::getTicksPerSecond)));
final int averagePlayersOnline = (int) MathUtils.averageInt(history.stream().map(TPS::getPlayers));
final double averageCPUUsage = MathUtils.round(MathUtils.averageDouble(history.stream().map(TPS::getCPUUsage)));
final long averageUsedMemory = MathUtils.averageLong(history.stream().map(TPS::getUsedMemory));
final int averageEntityCount = (int) MathUtils.averageInt(history.stream().map(TPS::getEntityCount));
final int averageChunksLoaded = (int) MathUtils.averageInt(history.stream().map(TPS::getChunksLoaded));
averages.add(new TPS(lastDate, averageTPS, averagePlayersOnline, averageCPUUsage, averageUsedMemory, averageEntityCount, averageChunksLoaded));
}
unsavedTPSHistory.removeAll(copy);
return averages;
}
/**
* Used to get the cached commandUse.
*
* @return Map with key:value - "/command":4
*/
public Map<String, Integer> getCommandUse() {
return commandUse;
}
/**
* Used to handle a command's execution.
*
* @param command "/command"
*/
public void handleCommand(String command) {
int amount = commandUse.getOrDefault(command, 0);
commandUse.put(command, amount + 1);
}
public void addTPSLastMinute(List<TPS> history) {
// Copy the contents to avoid reference, thus making the whole calculation pointless.
unsavedTPSHistory.add(new ArrayList<>(history));
}
}

531
Plan/src/main/java/com/djrapitops/plan/data/cache/DataCacheHandler.java vendored
View File

@ -1,531 +0,0 @@
package main.java.com.djrapitops.plan.data.cache;
import com.djrapitops.plugin.task.AbsRunnable;
import com.djrapitops.plugin.utilities.player.IPlayer;
import main.java.com.djrapitops.plan.Log;
import main.java.com.djrapitops.plan.Plan;
import main.java.com.djrapitops.plan.data.TPS;
import main.java.com.djrapitops.plan.data.UserData;
import main.java.com.djrapitops.plan.data.handling.info.HandlingInfo;
import main.java.com.djrapitops.plan.data.handling.info.LogoutInfo;
import main.java.com.djrapitops.plan.data.handling.info.ReloadInfo;
import main.java.com.djrapitops.plan.database.Database;
import main.java.com.djrapitops.plan.locale.Locale;
import main.java.com.djrapitops.plan.locale.Msg;
import main.java.com.djrapitops.plan.queue.DataCacheClearQueue;
import main.java.com.djrapitops.plan.queue.DataCacheGetQueue;
import main.java.com.djrapitops.plan.queue.DataCacheProcessQueue;
import main.java.com.djrapitops.plan.queue.DataCacheSaveQueue;
import main.java.com.djrapitops.plan.queue.processing.Processor;
import main.java.com.djrapitops.plan.utilities.Benchmark;
import main.java.com.djrapitops.plan.utilities.MiscUtils;
import main.java.com.djrapitops.plan.utilities.NewPlayerCreator;
import main.java.com.djrapitops.plan.utilities.analysis.MathUtils;
import org.bukkit.entity.Player;
import java.sql.SQLException;
import java.util.*;
/**
* This Class contains the Cache.
* <p>
* This class is the main processing class that initialises Save, Clear, Process
* and Get queue and Starts the asynchronous save task.
* <p>
* It is used to store command use, locations, active sessions and UserData
* objects in memory.
* <p>
* Its methods can be used to access all the data it stores and to clear them.
*
* @author Rsl1122
* @since 2.0.0
*/
public class DataCacheHandler extends SessionCache {
// Cache
private final Map<UUID, UserData> dataCache;
// Plan
private final Plan plugin;
private final Database db;
//Cache
private Map<String, Integer> commandUse;
private List<List<TPS>> unsavedTPSHistory;
// Queues
private DataCacheSaveQueue saveTask;
private DataCacheClearQueue clearTask;
private DataCacheProcessQueue processTask;
private DataCacheGetQueue getTask;
// Variables
private boolean periodicTaskIsSaving = false;
/**
* Class Constructor.
* <p>
* Gets the Database from the plugin. Starts the queues. Registers
* Asynchronous Periodic Save Task
*
* @param plugin Current instance of Plan
*/
public DataCacheHandler(Plan plugin) {
super(); // Initializes Session & Location cache.
this.plugin = plugin;
db = plugin.getDB();
dataCache = new HashMap<>();
startQueues();
commandUse = new HashMap<>();
if (!getCommandUseFromDb()) {
Log.error(Locale.get(Msg.ENABLE_DB_FAIL_DISABLE_INFO).toString());
plugin.disablePlugin();
return;
}
unsavedTPSHistory = new ArrayList<>();
startAsyncPeriodicSaveTask();
}
/**
* Used to get the initial commandUse Map from the database.
*
* @return Was the fetch successful?
*/
public boolean getCommandUseFromDb() {
try {
commandUse = db.getCommandUse();
return true;
} catch (Exception e) {
Log.toLog(this.getClass().getName(), e);
}
return false;
}
/**
* Used to start all processing Queue Threads.
*/
public void startQueues() {
getTask = new DataCacheGetQueue(plugin);
processTask = new DataCacheProcessQueue();
clearTask = new DataCacheClearQueue(this);
saveTask = new DataCacheSaveQueue(plugin, this);
}
/**
* Used to start the Asynchronous Save Task.
*
* @throws IllegalArgumentException BukkitRunnable was given wrong
* parameters.
* @throws IllegalStateException BukkitScheduler is in a wrong state.
*/
public void startAsyncPeriodicSaveTask() {
DataCacheHandler handler = this;
plugin.getRunnableFactory().createNew(new AbsRunnable("PeriodicCacheSaveTask") {
private int timesSaved = 0;
@Override
public void run() {
if (periodicTaskIsSaving) {
return;
}
try {
periodicTaskIsSaving = true;
Log.debug("Database", "Periodic Cache Save: " + dataCache.size());
handler.saveHandlerDataToCache();
handler.saveCachedUserData();
saveCommandUse();
saveUnsavedTPSHistory();
timesSaved++;
} catch (Exception e) {
Log.toLog(this.getClass().getName() + "(" + this.getName() + ")", e);
} finally {
periodicTaskIsSaving = false;
}
}
}).runTaskTimerAsynchronously(60L * 20L * 5, 60L * 20L * 5);
}
/**
* Uses Database or Cache to retrieve the UserData of a matching player.
* <p>
* Caches the data to the Cache if cache-parameter is true.
*
* @param processor DBCallableProcessor Object used to process the data
* after it was retrieved
* @param uuid Player's UUID
* @param cache Whether or not the UserData will be Cached in this instance
* of DataCacheHandler after it has been fetched (if not already fetched)
*/
public void getUserDataForProcessing(DBCallableProcessor processor, UUID uuid, boolean cache) {
UserData uData = dataCache.get(uuid);
if (uData == null) {
if (cache) {
DBCallableProcessor cacher = this::cache;
getTask.scheduleForGet(uuid, cacher, processor);
} else {
getTask.scheduleForGet(uuid, processor);
}
} else {
processor.process(uData);
}
}
/**
* Used to Cache a UserData object to the Cache.
* <p>
* If a object already exists it will be replaced.
*
* @param data UserData object with the UUID inside used as key.
*/
public void cache(UserData data) {
data.setOnline(true);
dataCache.put(data.getUuid(), data);
Log.debug("Added " + data.getUuid().toString() + " to Cache.");
}
/**
* Uses Database or Cache to retrieve the UserData of a matching player.
* <p>
* Always Caches the data after retrieval (unless already cached)
*
* @param processor DBCallableProcessor Object used to process the data
* after it was retrieved
* @param uuid Player's UUID
*/
public void getUserDataForProcessing(DBCallableProcessor processor, UUID uuid) {
getUserDataForProcessing(processor, uuid, true);
}
/**
* Saves all UserData in the cache to Database.
* <p>
* Should only be called from Async thread
*/
public void saveCachedUserData() {
Set<UserData> data = new HashSet<>();
data.addAll(dataCache.values());
try {
db.saveMultipleUserData(data);
} catch (SQLException ex) {
Log.toLog(this.getClass().getName(), ex);
}
}
/**
* Used to add event HandlingInfo to the processTask's pool.
* <p>
* Given HandlingInfo object's process method will be called.
*
* @param i Object that extends HandlingInfo.
*/
@Deprecated
public void addToPool(HandlingInfo i) {
if (i == null) {
return;
}
processTask.addToQueue(i);
}
/**
* Saves all data in the cache to Database and closes the database down.
* <p>
* Stops all tasks.
* <p>
* If processTask has unprocessed information, it will be processed.
*/
public void saveCacheOnDisable() {
long time = MiscUtils.getTime();
Benchmark.start("Cache: SaveOnDisable");
saveTask.stop();
getTask.stop();
clearTask.stop();
List<Processor> toProcess = processTask.stopAndReturnLeftovers();
Benchmark.start("Cache: ProcessOnlineHandlingInfo");
Log.debug("ToProcess size: " + toProcess.size() + " DataCache size: " + dataCache.keySet().size());
List<IPlayer> onlinePlayers = plugin.fetch().getOnlinePlayers();
Log.debug("Online: " + onlinePlayers.size());
for (IPlayer p : onlinePlayers) {
UUID uuid = p.getUuid();
endSession(uuid);
String worldName = ((Player) p.getWrappedPlayerClass()).getWorld().getName();
toProcess.add(new LogoutInfo(uuid, time, p.isBanned(), p.getGamemode().name(), getSession(uuid), worldName));
}
Log.debug("ToProcess size_AFTER: " + toProcess.size() + " DataCache size: " + dataCache.keySet().size());
// toProcess.sort(new HandlingInfoTimeComparator());
processUnprocessedHandlingInfo(toProcess);
Benchmark.stop("Cache: ProcessOnlineHandlingInfo");
List<UserData> data = new ArrayList<>();
data.addAll(dataCache.values());
Log.debug("SAVING, DataCache size: " + dataCache.keySet().size());
try {
db.saveCommandUse(commandUse);
} catch (SQLException e) {
Log.toLog(this.getClass().getName(), e);
}
try {
db.saveMultipleUserData(data);
} catch (SQLException e) {
Log.toLog(this.getClass().getName(), e);
}
saveUnsavedTPSHistory();
try {
db.close();
} catch (SQLException e) {
Log.toLog(this.getClass().getName(), e);
}
Benchmark.stop("Cache: SaveOnDisable");
}
private void processUnprocessedHandlingInfo(List<Processor> toProcess) {
Log.debug("PROCESS: " + toProcess.size());
for (Processor i : toProcess) {
i.process();
}
}
/**
* Saves the cached data of matching Player if it is in the cache.
*
* @param uuid Player's UUID
*/
public void saveCachedData(UUID uuid) {
DBCallableProcessor saveProcessor = data -> {
data.access();
data.setClearAfterSave(true);
saveTask.scheduleForSave(data);
};
getUserDataForProcessing(saveProcessor, uuid);
}
/**
* Saves the cached CommandUse.
* <p>
* Should be only called from an Asynchronous Thread.
*/
public void saveCommandUse() {
try {
db.saveCommandUse(new HashMap<>(commandUse));
} catch (SQLException | NullPointerException e) {
Log.toLog(this.getClass().getName(), e);
}
}
public void saveUnsavedTPSHistory() {
List<TPS> averages = calculateAverageTpsForEachMinute();
if (averages.isEmpty()) {
return;
}
try {
Log.debug("Database", "Periodic TPS Save: " + averages.size());
db.getTpsTable().saveTPSData(averages);
} catch (SQLException ex) {
Log.toLog(this.getClass().getName(), ex);
}
}
private List<TPS> calculateAverageTpsForEachMinute() {
final List<TPS> averages = new ArrayList<>();
if (unsavedTPSHistory.isEmpty()) {
return new ArrayList<>();
}
List<List<TPS>> copy = new ArrayList<>(unsavedTPSHistory);
for (List<TPS> history : copy) {
final long lastDate = history.get(history.size() - 1).getDate();
final double averageTPS = MathUtils.round(MathUtils.averageDouble(history.stream().map(TPS::getTicksPerSecond)));
final int averagePlayersOnline = (int) MathUtils.averageInt(history.stream().map(TPS::getPlayers));
final double averageCPUUsage = MathUtils.round(MathUtils.averageDouble(history.stream().map(TPS::getCPUUsage)));
final long averageUsedMemory = MathUtils.averageLong(history.stream().map(TPS::getUsedMemory));
final int averageEntityCount = (int) MathUtils.averageInt(history.stream().map(TPS::getEntityCount));
final int averageChunksLoaded = (int) MathUtils.averageInt(history.stream().map(TPS::getChunksLoaded));
averages.add(new TPS(lastDate, averageTPS, averagePlayersOnline, averageCPUUsage, averageUsedMemory, averageEntityCount, averageChunksLoaded));
}
unsavedTPSHistory.removeAll(copy);
return averages;
}
/**
* Refreshes the calculations for all online players with ReloadInfo.
*/
public void saveHandlerDataToCache() {
final List<IPlayer> onlinePlayers = plugin.fetch().getOnlinePlayers();
onlinePlayers.forEach(p -> saveHandlerDataToCache(p, false));
}
private void saveHandlerDataToCache(IPlayer p, boolean pool) {
long time = MiscUtils.getTime();
UUID uuid = p.getUuid();
String worldName = ((Player) p.getWrappedPlayerClass()).getWorld().getName();
ReloadInfo info = new ReloadInfo(uuid, time, p.getAddress().getAddress(), p.isBanned(), p.getDisplayName(), p.getGamemode().name(), worldName);
if (!pool) {
UserData data = dataCache.get(uuid);
if (data != null) {
info.process(data);
return;
}
}
addToPool(info);
}
/**
* Schedules all UserData from the Cache to be cleared.
*/
public void clearCache() {
clearTask.scheduleForClear(dataCache.keySet());
}
/**
* Clears the matching UserData from the Cache if they're not online.
*
* @param uuid Player's UUID
*/
public void clearFromCache(UUID uuid) {
if (plugin.fetch().isOnline(uuid)) {
UserData data = dataCache.get(uuid);
if (data != null) {
data.setClearAfterSave(false);
}
} else {
dataCache.remove(uuid);
Log.debug("Cleared " + uuid.toString() + " from Cache.");
}
}
/**
* Schedules a matching UserData object to be cleared from the cache.
*
* @param uuid Player's UUID.
*/
public void scheduldeForClear(UUID uuid) {
clearTask.scheduleForClear(uuid);
}
/**
* Check whether or not the UserData object is being accessed by save or
* process tasks.
*
* @param uuid Player's UUID
* @return true/false
*/
public boolean isDataAccessed(UUID uuid) {
UserData userData = dataCache.get(uuid);
if (userData == null) {
return false;
}
/*TODO boolean isAccessed = (userData.isAccessed()) || saveTask.containsUUID(uuid) || processTask.containsUUID(uuid);
if (isAccessed) {
userData.setClearAfterSave(false);
}
return isAccessed;*/
return true;
}
/**
* Creates a new UserData instance and saves it to the Database.
*
* @param player Player the new UserData is created for
*/
public void newPlayer(IPlayer player) {
newPlayer(NewPlayerCreator.createNewPlayer(player));
}
/**
* Schedules a new player's data to be saved to the Database.
*
* @param data UserData object to schedule for save.
*/
public void newPlayer(UserData data) {
saveTask.scheduleNewPlayer(data);
cache(data);
}
/**
* Used to get the contents of the cache.
*
* @return The Map containing all Cached UserData
*/
public Map<UUID, UserData> getDataCache() {
return dataCache;
}
/**
* Used to get the cached commandUse.
*
* @return Map with key:value - "/command":4
*/
public Map<String, Integer> getCommandUse() {
return commandUse;
}
/**
* If /reload is run this treats every online player as a new login.
* <p>
* Calls all the methods that are ran when PlayerJoinEvent is fired
*/
public void handleReload() {
plugin.getRunnableFactory().createNew(new AbsRunnable("ReloadCacheUpdateTask") {
@Override
public void run() {
final List<IPlayer> onlinePlayers = plugin.fetch().getOnlinePlayers();
for (IPlayer player : onlinePlayers) {
UUID uuid = player.getUuid();
boolean isNewPlayer = !db.wasSeenBefore(uuid);
if (isNewPlayer) {
newPlayer(player);
}
startSession(uuid);
saveHandlerDataToCache(player, true);
}
this.cancel();
}
}).runTaskAsynchronously();
}
/**
* Used to handle a command's execution.
*
* @param command "/command"
*/
public void handleCommand(String command) {
int amount = commandUse.getOrDefault(command, 0);
commandUse.put(command, amount + 1);
}
/**
* @return The SaveTask
*/
public DataCacheSaveQueue getSaveTask() {
return saveTask;
}
/**
* @return The ClearTask
*/
public DataCacheClearQueue getClearTask() {
return clearTask;
}
/**
* @return The ProcessTask
*/
public DataCacheProcessQueue getProcessTask() {
return processTask;
}
/**
* @return The GetTask
*/
public DataCacheGetQueue getGetTask() {
return getTask;
}
public void addTPSLastMinute(List<TPS> history) {
// Copy the contents to avoid reference, thus making the whole calculation pointless.
unsavedTPSHistory.add(new ArrayList<>(history));
}
}

18
Plan/src/main/java/com/djrapitops/plan/data/cache/InspectCacheHandler.java vendored
View File

@ -23,7 +23,7 @@ import java.util.*;
@Deprecated
public class InspectCacheHandler {
private final DataCacheHandler handler;
private final DataCache handler;
private final Map<UUID, UserData> cache;
private final Map<UUID, Long> cacheTimes;
@ -46,6 +46,7 @@ public class InspectCacheHandler {
*
* @param uuid UUID of the player.
*/
@Deprecated // Does not cache anything anymore // TODO Remove
public void cache(UUID uuid) {
DBCallableProcessor cacher = data -> {
UserData userData = new UserData(data);
@ -62,8 +63,6 @@ public class InspectCacheHandler {
Log.toLog(this.getClass().getName(), e);
}
};
handler.getUserDataForProcessing(cacher, uuid, false);
}
/**
@ -74,18 +73,7 @@ public class InspectCacheHandler {
* @throws SQLException If Database is not properly enabled
*/
public void cacheAllUserData(Database db) throws SQLException {
Set<UUID> cachedUserData = handler.getDataCache().keySet();
for (UUID uuid : cachedUserData) {
cache(uuid);
}
Set<UUID> savedUUIDs = new HashSet<>();
try {
savedUUIDs = db.getUsersTable().getSavedUUIDs();
} catch (SQLException ex) {
Log.toLog(this.getClass().getName(), ex);
}
savedUUIDs.removeAll(cachedUserData);
List<UserData> userDataForUUIDS = db.getUserDataForUUIDS(savedUUIDs);
List<UserData> userDataForUUIDS = db.getUserDataForUUIDS(db.getUsersTable().getSavedUUIDs());
long time = MiscUtils.getTime();
for (UserData uData : userDataForUUIDS) {
UUID uuid = uData.getUuid();

38
Plan/src/main/java/com/djrapitops/plan/data/cache/SessionCache.java vendored
View File

@ -1,8 +1,6 @@
package main.java.com.djrapitops.plan.data.cache;
import main.java.com.djrapitops.plan.data.SessionData;
import main.java.com.djrapitops.plan.data.UserData;
import main.java.com.djrapitops.plan.utilities.MiscUtils;
import java.util.HashMap;
import java.util.Map;
@ -22,6 +20,18 @@ public class SessionCache {
* Class Constructor.
*/
public SessionCache() {
}
public void cacheSession(UUID uuid, SessionData session) {
activeSessions.put(uuid, session);
}
public void endSession(UUID uuid, long time) {
SessionData session = activeSessions.get(uuid);
if (session == null) {
return;
}
session.endSession(time);
}
@ -30,9 +40,8 @@ public class SessionCache {
*
* @param uuid UUID of the player.
*/
@Deprecated
public void startSession(UUID uuid) {
SessionData session = new SessionData(MiscUtils.getTime());
activeSessions.put(uuid, session);
}
/**
@ -40,11 +49,8 @@ public class SessionCache {
*
* @param uuid UUID of the player.
*/
@Deprecated
public void endSession(UUID uuid) {
SessionData currentSession = activeSessions.get(uuid);
if (currentSession != null) {
currentSession.endSession(MiscUtils.getTime());
}
}
/**
@ -53,24 +59,11 @@ public class SessionCache {
* @param uuid UUID of the player.
* @return SessionData or null if not cached.
*/
@Deprecated
public SessionData getSession(UUID uuid) {
return activeSessions.get(uuid);
}
/**
* Add a session to the UserData object if it is cached and has been ended.
*
* @param data UserData object a session should be added to.
*/
public void addSession(UserData data) {
UUID uuid = data.getUuid();
SessionData currentSession = activeSessions.get(uuid);
if (currentSession != null && currentSession.isValid() && !data.getSessions().contains(currentSession)) {
data.addSession(currentSession);
activeSessions.remove(uuid);
}
}
/**
* Used to get the Map of active sessions.
* <p>
@ -78,6 +71,7 @@ public class SessionCache {
*
* @return key:value UUID:SessionData
*/
@Deprecated
public Map<UUID, SessionData> getActiveSessions() {
return activeSessions;
}

31
Plan/src/main/java/com/djrapitops/plan/data/handling/ChatHandling.java
View File

@ -1,31 +0,0 @@
package main.java.com.djrapitops.plan.data.handling;
import main.java.com.djrapitops.plan.data.UserData;
/**
* Class containing static methods for processing information contained in a
* ChatEvent.
*
* @author Rsl1122
* @since 3.0.0
*/
public class ChatHandling {
/**
* Constructor used to hide the public constructor
*/
private ChatHandling() {
throw new IllegalStateException("Utility class");
}
/**
* Processes the information of the Event and changes UserData object
* accordingly.
*
* @param data UserData of the player.
* @param nickname Nickname of the player during the event.
*/
public static void processChatInfo(UserData data, String nickname) {
data.addNickname(nickname);
}
}

5
Plan/src/main/java/com/djrapitops/plan/data/handling/KillHandling.java
View File

@ -2,7 +2,6 @@ package main.java.com.djrapitops.plan.data.handling;
import main.java.com.djrapitops.plan.Log;
import main.java.com.djrapitops.plan.Plan;
import main.java.com.djrapitops.plan.data.KillData;
import main.java.com.djrapitops.plan.data.UserData;
import org.apache.commons.lang3.text.WordUtils;
import org.bukkit.Material;
@ -48,12 +47,12 @@ public class KillHandling {
if (victimID == -1) {
return;
}
data.addPlayerKill(new KillData(victimUUID, victimID, weaponName, time));
//TODO Move to Session data.addPlayerKill(new KillData(victimUUID, victimID, weaponName, time));
} catch (SQLException e) {
Log.toLog("main.java.com.djrapitops.plan.KillHandling", e);
}
} else {
data.setMobKills(data.getMobKills() + 1);
//TODO Move to Session data.setMobKills(data.getMobKills() + 1);
}
}

58
Plan/src/main/java/com/djrapitops/plan/data/handling/LoginHandling.java
View File

@ -1,58 +0,0 @@
package main.java.com.djrapitops.plan.data.handling;
import main.java.com.djrapitops.plan.data.UserData;
import main.java.com.djrapitops.plan.data.cache.GeolocationCacheHandler;
import java.net.InetAddress;
/**
* Class containing static methods for processing information contained in a
* JoinEvent.
*
* @author Rsl1122
* @since 3.0.0
*/
public class LoginHandling {
/**
* Utility Class, hides constructor.
*/
private LoginHandling() {
throw new IllegalStateException("Utility Class.");
}
/**
* Processes the information of the Event and changes UserData object
* accordingly.
*
* @param data UserData of the player.
* @param time Epoch ms the event occurred.
* @param ip IP of the player
* @param banned Is the player banned
* @param nickname Nickname of the player
* @param loginTimes amount the loginTimes should be incremented with.
*/
public static void processLoginInfo(UserData data, long time, InetAddress ip, boolean banned, String nickname, int loginTimes) {
data.setLastPlayed(time);
data.updateBanned(banned);
data.setLoginTimes(data.getLoginTimes() + loginTimes);
data.addNickname(nickname);
data.addIpAddress(ip);
updateGeolocation(ip, data);
}
/**
* Updates the geolocation of the player.
* <p>
* Uses free service of freegeoip.net. 15000 requests can be sent per hour.
*
* @param ip InetAddress used for location.
* @param data UserData of the player.
* @see GeolocationCacheHandler
*/
public static void updateGeolocation(InetAddress ip, UserData data) {
String geoLocation = GeolocationCacheHandler.getCountry(ip.getHostAddress());
data.setGeolocation(geoLocation);
}
}

34
Plan/src/main/java/com/djrapitops/plan/data/handling/LogoutHandling.java
View File

@ -1,34 +0,0 @@
package main.java.com.djrapitops.plan.data.handling;
import main.java.com.djrapitops.plan.data.UserData;
/**
* Class containing static methods for processing information contained in a
* QuitEvent.
*
* @author Rsl1122
* @since 3.0.0
*/
public class LogoutHandling {
/**
* Constructor used to hide the public constructor
*/
private LogoutHandling() {
throw new IllegalStateException("Utility class");
}
/**
* Processes the information of the Event and changes UserData object
* accordingly.
*
* @param data UserData of the player.
* @param time Epoch ms the event occurred.
* @param banned Is the player banned?
*/
public static void processLogoutInfo(UserData data, long time, boolean banned) {
data.setPlayTime(data.getPlayTime() + (time - data.getLastPlayed()));
data.setLastPlayed(time);
data.updateBanned(banned);
}
}

28
Plan/src/main/java/com/djrapitops/plan/data/handling/PlaytimeHandling.java
View File

@ -1,28 +0,0 @@
package main.java.com.djrapitops.plan.data.handling;
import main.java.com.djrapitops.plan.data.UserData;
import main.java.com.djrapitops.plan.data.time.GMTimes;
import main.java.com.djrapitops.plan.data.time.WorldTimes;
public class PlaytimeHandling {
/**
* Constructor used to hide the public constructor
*/
private PlaytimeHandling() {
throw new IllegalStateException("Utility class");
}
public static void processPlaytimeDependentInfo(UserData data, long time, String gamemode, String worldName) {
long diff = time - data.getLastPlayed();
long playTime = data.getPlayTime() + diff;
data.setPlayTime(playTime);
data.setLastPlayed(time);
GMTimes gmTimes = data.getGmTimes();
gmTimes.changeState(gamemode != null ? gamemode : gmTimes.getState(), playTime);
WorldTimes worldTimes = data.getWorldTimes();
// TODO worldTimes.changeState(worldName, playTime);
}
}

54
Plan/src/main/java/com/djrapitops/plan/data/handling/importing/ImportUtils.java
View File

@ -1,54 +0,0 @@
package main.java.com.djrapitops.plan.data.handling.importing;
import com.djrapitops.pluginbridge.plan.importing.OnTimeImporter;
import main.java.com.djrapitops.plan.Log;
import java.util.HashMap;
import java.util.Map;
import static org.bukkit.Bukkit.getPluginManager;
/**
* This class is responsible for static utility methods used for importing.
*
* @author Rsl1122
* @since 3.2.0
*/
@Deprecated
public class ImportUtils {
/**
* Constructor used to hide the public constructor
*/
private ImportUtils() {
throw new IllegalStateException("Utility class");
}
/**
* Checks if a plugin is enabled.
*
* @param pluginName Name of the plugin
* @return true/false
*/
public static boolean isPluginEnabled(String pluginName) {
return "offline".equals(pluginName) || getPluginManager().isPluginEnabled(pluginName);
}
/**
* Used to get all importers for different plugins.
*
* @return Map of importers with pluginname in lowercase as key.
*/
public static Map<String, Importer> getImporters() {
Map<String, Importer> importers = new HashMap<>();
try {
importers.put("ontime", new OnTimeImporter());
importers.put("offline", new OfflinePlayerImporter());
} catch (Exception e) {
Log.toLog("ImportUtils.getImporters", e);
Log.error("Plan Plugin Bridge not included in the plugin jar.");
}
return importers;
}
}

149
Plan/src/main/java/com/djrapitops/plan/data/handling/importing/Importer.java
View File

@ -1,154 +1,11 @@
package main.java.com.djrapitops.plan.data.handling.importing;
import com.djrapitops.plugin.utilities.player.Fetch;
import com.djrapitops.plugin.utilities.player.IOfflinePlayer;
import main.java.com.djrapitops.plan.Log;
import main.java.com.djrapitops.plan.Plan;
import main.java.com.djrapitops.plan.data.UserData;
import main.java.com.djrapitops.plan.data.cache.DataCacheHandler;
import main.java.com.djrapitops.plan.data.handling.info.HandlingInfo;
import main.java.com.djrapitops.plan.data.handling.info.InfoType;
import main.java.com.djrapitops.plan.database.Database;
import main.java.com.djrapitops.plan.utilities.Benchmark;
import main.java.com.djrapitops.plan.utilities.NewPlayerCreator;
import java.sql.SQLException;
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
/**
* Abstract class used for importing data from other plugins.
*
* @author Rsl1122
* @since 3.2.0
* @since 4.0.0
*/
@Deprecated
public abstract class Importer {
private String info;
/**
* Constructor.
*/
public Importer() {
info = "No info specified";
}
/**
* Method used for the import.
* <p>
* Creates UserData for players that have not been saved to the database.
*
* @param uuids UUIDs to be imported
* @param args arguments for the import
* @return success
*/
public boolean importData(Collection<UUID> uuids, String... args) {
Plan plan = Plan.getInstance();
plan.getAnalysisCache().disableAnalysisTemporarily();
String processName = "Import, " + getClass().getSimpleName();
try {
DataCacheHandler handler = plan.getHandler();
Database db = plan.getDB();
Benchmark.start(processName);
Set<UUID> saved;
saved = db.getSavedUUIDs();
List<UUID> unSaved = new ArrayList<>(uuids);
unSaved.removeAll(saved);
int amount = unSaved.size();
String createUserObjects = "Creating " + amount + " new UserData objects";
Log.debug(processName, createUserObjects);
Map<UUID, IOfflinePlayer> offlinePlayers = Fetch.getIOfflinePlayers().stream().collect(Collectors.toMap(IOfflinePlayer::getUuid, Function.identity()));
Benchmark.start(createUserObjects);
List<UserData> newUsers = new ArrayList<>();
List<IOfflinePlayer> offlineP = unSaved
.stream()
.map(offlinePlayers::get)
.collect(Collectors.toList());
AtomicInteger currentUser = new AtomicInteger(0);
AtomicInteger currentPercent = new AtomicInteger(0);
int fivePercent = amount / 20;
//Using Set because of better Collection#contains() performance
Set<Integer> milestones = IntStream.rangeClosed(1, 20)
.mapToObj(i -> i * fivePercent)
.collect(Collectors.toSet());
offlineP.parallelStream()
.map(NewPlayerCreator::createNewOfflinePlayer)
.forEach(newPlayer -> {
newPlayer.setLastPlayed(newPlayer.getRegistered());
newUsers.add(newPlayer);
if (milestones.contains(currentUser.incrementAndGet())) {
Log.debug(processName, "Creating new UserData objects: " + currentPercent.addAndGet(5) + "%");
}
});
Benchmark.stop(processName, createUserObjects);
Log.debug(processName, "Save new UserData objects (" + amount + ")");
plan.getDB().saveMultipleUserData(newUsers);
for (UUID uuid : uuids) {
handler.addToPool(importData(uuid, args));
}
} catch (SQLException ex) {
Log.toLog(this.getClass().getName(), ex);
return false;
} finally {
plan.getAnalysisCache().enableAnalysis();
Log.logDebug(processName, Benchmark.stop(processName, processName));
}
return true;
}
/**
* Returns the info for import command.
*
* @return Information about the import options
* @since 3.5.0
*/
public final String getInfo() {
return info;
}
/**
* Set the info for import command.
*
* @param info Information about the import options
* @since 3.5.0
*/
public final void setInfo(String info) {
this.info = info;
}
/**
* Method used for getting the HandlingInfo object for the import data.
*
* @param uuid UUID of the player
* @param args Arguments for import
* @return HandlingInfo object that modifies the UserData so that the data
* is imported.
* @since 3.5.0
*/
public HandlingInfo importData(UUID uuid, String... args) {
return new HandlingInfo(uuid, InfoType.OTHER, 0) {
@Override
public void process(UserData uData) {
}
};
}
}
// TODO write new Importer
}

11
Plan/src/main/java/com/djrapitops/plan/data/handling/importing/OfflinePlayerImporter.java
View File

@ -1,24 +1,15 @@
package main.java.com.djrapitops.plan.data.handling.importing;
import main.java.com.djrapitops.plan.data.handling.info.HandlingInfo;
import java.util.UUID;
/**
* Imports all players who have not joined since Plan was installed.
*
* @author Rsl1122
* @since 3.5.0
*/
@Deprecated
public class OfflinePlayerImporter extends Importer {
public OfflinePlayerImporter() {
super.setInfo("Import all players who have not joined since Plan was installed.");
// TODO Rewrite
}
@Override
public HandlingInfo importData(UUID uuid, String... args) {
return null;
}
}

7
Plan/src/main/java/com/djrapitops/plan/data/handling/info/ChatInfo.java
View File

@ -1,7 +1,6 @@
package main.java.com.djrapitops.plan.data.handling.info;
import main.java.com.djrapitops.plan.data.UserData;
import main.java.com.djrapitops.plan.data.handling.ChatHandling;
import java.util.UUID;
@ -11,6 +10,7 @@ import java.util.UUID;
* @author Rsl1122
* @since 3.0.0
*/
@Deprecated // TODO Update Straight to db
public class ChatInfo extends HandlingInfo {
private final String nickname;
@ -28,9 +28,6 @@ public class ChatInfo extends HandlingInfo {
@Override
public void process(UserData uData) {
if (!uData.getUuid().equals(uuid)) {
return;
}
ChatHandling.processChatInfo(uData, nickname);
}
}

2
Plan/src/main/java/com/djrapitops/plan/data/handling/info/DeathInfo.java
View File

@ -26,6 +26,6 @@ public class DeathInfo extends HandlingInfo {
if (!uData.getUuid().equals(uuid)) {
return;
}
uData.setDeaths(uData.getDeaths() + 1);
//TODO uData.setDeaths(uData.getDeaths() + 1);
}
}

5
Plan/src/main/java/com/djrapitops/plan/data/handling/info/HandlingInfo.java
View File

@ -1,6 +1,5 @@
package main.java.com.djrapitops.plan.data.handling.info;
import main.java.com.djrapitops.plan.Plan;
import main.java.com.djrapitops.plan.data.UserData;
import main.java.com.djrapitops.plan.data.cache.DBCallableProcessor;
import main.java.com.djrapitops.plan.queue.processing.Processor;
@ -14,7 +13,8 @@ import java.util.UUID;
* @author Rsl1122
* @since 3.0.0
*/
public abstract class HandlingInfo extends Processor<UUID> implements DBCallableProcessor{
// TODO Rewrite all HandlingInfo objects to only extend Processor
public abstract class HandlingInfo extends Processor<UUID> implements DBCallableProcessor {
final UUID uuid;
final InfoType type;
@ -63,7 +63,6 @@ public abstract class HandlingInfo extends Processor<UUID> implements DBCallable
}
public void process() {
Plan.getInstance().getHandler().getUserDataForProcessing(this, uuid);
}
/**

5
Plan/src/main/java/com/djrapitops/plan/data/handling/info/KickInfo.java
View File

@ -10,6 +10,7 @@ import java.util.UUID;
* @author Rsl1122
* @since 3.0.0
*/
@Deprecated //TODO Update Straight to db
public class KickInfo extends HandlingInfo {
/**
@ -23,10 +24,6 @@ public class KickInfo extends HandlingInfo {
@Override
public void process(UserData uData) {
if (!uData.getUuid().equals(uuid)) {
return;
}
uData.setTimesKicked(uData.getTimesKicked() + 1);
}
}

7
Plan/src/main/java/com/djrapitops/plan/data/handling/info/LoginInfo.java
View File

@ -1,7 +1,6 @@
package main.java.com.djrapitops.plan.data.handling.info;
import main.java.com.djrapitops.plan.data.UserData;
import main.java.com.djrapitops.plan.data.handling.LoginHandling;
import java.net.InetAddress;
import java.util.UUID;
@ -12,6 +11,7 @@ import java.util.UUID;
* @author Rsl1122
* @since 3.0.0
*/
@Deprecated // TODO Update in listener to db
public class LoginInfo extends HandlingInfo {
private final InetAddress ip;
@ -63,10 +63,5 @@ public class LoginInfo extends HandlingInfo {
@Override
public void process(UserData uData) {
if (!uData.getUuid().equals(uuid)) {
return;
}
LoginHandling.processLoginInfo(uData, time, ip, banned, nickname, loginTimes);
playtimeDependentInfo.process(uData);
}
}

15
Plan/src/main/java/com/djrapitops/plan/data/handling/info/LogoutInfo.java
View File

@ -1,8 +1,6 @@
package main.java.com.djrapitops.plan.data.handling.info;
import main.java.com.djrapitops.plan.data.SessionData;
import main.java.com.djrapitops.plan.data.UserData;
import main.java.com.djrapitops.plan.data.handling.LogoutHandling;
import java.util.UUID;
@ -12,10 +10,10 @@ import java.util.UUID;
* @author Rsl1122
* @since 3.0.0
*/
@Deprecated //TODO Update straight to db
public class LogoutInfo extends HandlingInfo {
private final boolean banned;
private final SessionData sData;
private final PlaytimeDependentInfo playtimeDependentInfo;
/**
@ -25,24 +23,15 @@ public class LogoutInfo extends HandlingInfo {
* @param time Epoch ms of the event.
* @param banned Is the player banned
* @param gm current gamemode of the player
* @param sData session that has been ended at the moment of the logout
* event.
*/
public LogoutInfo(UUID uuid, long time, boolean banned, String gm, SessionData sData, String worldName) {
public LogoutInfo(UUID uuid, long time, boolean banned, String gm, String worldName) {
super(uuid, InfoType.LOGOUT, time);
this.banned = banned;
this.sData = sData;
this.playtimeDependentInfo = new PlaytimeDependentInfo(uuid, InfoType.OTHER, time, gm, worldName);
}
@Override
public void process(UserData uData) {
if (!uData.getUuid().equals(uuid)) {
return;
}
uData.addSession(sData);
LogoutHandling.processLogoutInfo(uData, time, banned);
playtimeDependentInfo.process(uData);
}
}

2
Plan/src/main/java/com/djrapitops/plan/data/handling/info/PlaytimeDependentInfo.java
View File

@ -1,7 +1,6 @@
package main.java.com.djrapitops.plan.data.handling.info;
import main.java.com.djrapitops.plan.data.UserData;
import main.java.com.djrapitops.plan.data.handling.PlaytimeHandling;
import java.util.UUID;
@ -22,6 +21,5 @@ public class PlaytimeDependentInfo extends HandlingInfo {
if (!uuid.equals(uData.getUuid())) {
return;
}
PlaytimeHandling.processPlaytimeDependentInfo(uData, time, gamemode, worldName);
}
}

7
Plan/src/main/java/com/djrapitops/plan/data/listeners/PlanChatListener.java
View File

@ -1,7 +1,6 @@
package main.java.com.djrapitops.plan.data.listeners;
import main.java.com.djrapitops.plan.Plan;
import main.java.com.djrapitops.plan.data.cache.DataCacheHandler;
import main.java.com.djrapitops.plan.data.handling.info.ChatInfo;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
@ -16,7 +15,7 @@ import org.bukkit.event.player.AsyncPlayerChatEvent;
*/
public class PlanChatListener implements Listener {
private final DataCacheHandler handler;
private Plan plugin;
/**
* Class Constructor.
@ -24,7 +23,7 @@ public class PlanChatListener implements Listener {
* @param plugin Current instance of Plan
*/
public PlanChatListener(Plan plugin) {
handler = plugin.getHandler();
this.plugin = plugin;
}
/**
@ -39,6 +38,6 @@ public class PlanChatListener implements Listener {
}
Player p = event.getPlayer();
handler.addToPool(new ChatInfo(p.getUniqueId(), p.getDisplayName()));
plugin.addToProcessQueue(new ChatInfo(p.getUniqueId(), p.getDisplayName()));
}
}

4
Plan/src/main/java/com/djrapitops/plan/data/listeners/PlanCommandPreprocessListener.java
View File

@ -4,7 +4,7 @@ import main.java.com.djrapitops.plan.Log;
import main.java.com.djrapitops.plan.Permissions;
import main.java.com.djrapitops.plan.Plan;
import main.java.com.djrapitops.plan.Settings;
import main.java.com.djrapitops.plan.data.cache.DataCacheHandler;
import main.java.com.djrapitops.plan.data.cache.DataCache;
import org.bukkit.command.Command;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
@ -20,7 +20,7 @@ import org.bukkit.event.player.PlayerCommandPreprocessEvent;
public class PlanCommandPreprocessListener implements Listener {
private final Plan plugin;
private final DataCacheHandler handler;
private final DataCache handler;
/**
* Class Constructor.

11
Plan/src/main/java/com/djrapitops/plan/data/listeners/PlanDeathEventListener.java
View File

@ -1,7 +1,6 @@
package main.java.com.djrapitops.plan.data.listeners;
import main.java.com.djrapitops.plan.Plan;
import main.java.com.djrapitops.plan.data.cache.DataCacheHandler;
import main.java.com.djrapitops.plan.data.handling.KillHandling;
import main.java.com.djrapitops.plan.data.handling.info.DeathInfo;
import main.java.com.djrapitops.plan.data.handling.info.KillInfo;
@ -23,7 +22,7 @@ import org.bukkit.projectiles.ProjectileSource;
*/
public class PlanDeathEventListener implements Listener {
private final DataCacheHandler handler;
private final Plan plugin;
/**
* Class Constructor.
@ -31,7 +30,7 @@ public class PlanDeathEventListener implements Listener {
* @param plugin Current instance of Plan
*/
public PlanDeathEventListener(Plan plugin) {
this.handler = plugin.getHandler();
this.plugin = plugin;
}
/**
@ -46,7 +45,7 @@ public class PlanDeathEventListener implements Listener {
LivingEntity dead = event.getEntity();
if (dead instanceof Player) {
handler.addToPool(new DeathInfo(dead.getUniqueId()));
plugin.addToProcessQueue(new DeathInfo(dead.getUniqueId()));
}
EntityDamageEvent entityDamageEvent = dead.getLastDamageCause();
@ -70,7 +69,7 @@ public class PlanDeathEventListener implements Listener {
}
}
handler.addToPool(new KillInfo(killer.getUniqueId(), time, dead, KillHandling.normalizeMaterialName(itemInHand)));
plugin.addToProcessQueue(new KillInfo(killer.getUniqueId(), time, dead, KillHandling.normalizeMaterialName(itemInHand)));
return;
}
@ -87,7 +86,7 @@ public class PlanDeathEventListener implements Listener {
return;
}
handler.addToPool(new KillInfo(owner.getUniqueId(), time, dead, "Wolf"));
plugin.addToProcessQueue(new KillInfo(owner.getUniqueId(), time, dead, "Wolf"));
}
if (killerEntity instanceof Arrow) {

7
Plan/src/main/java/com/djrapitops/plan/data/listeners/PlanGamemodeChangeListener.java
View File

@ -1,7 +1,6 @@
package main.java.com.djrapitops.plan.data.listeners;
import main.java.com.djrapitops.plan.Plan;
import main.java.com.djrapitops.plan.data.cache.DataCacheHandler;
import main.java.com.djrapitops.plan.data.handling.info.InfoType;
import main.java.com.djrapitops.plan.data.handling.info.PlaytimeDependentInfo;
import main.java.com.djrapitops.plan.utilities.MiscUtils;
@ -20,7 +19,7 @@ import java.util.UUID;
*/
public class PlanGamemodeChangeListener implements Listener {
private final DataCacheHandler handler;
private final Plan plugin;
/**
* Class Constructor.
@ -28,7 +27,7 @@ public class PlanGamemodeChangeListener implements Listener {
* @param plugin Current instance of Plan
*/
public PlanGamemodeChangeListener(Plan plugin) {
handler = plugin.getHandler();
this.plugin = plugin;
}
/**
@ -48,6 +47,6 @@ public class PlanGamemodeChangeListener implements Listener {
String gameMode = event.getNewGameMode().name();
String worldName = p.getWorld().getName();
handler.addToPool(new PlaytimeDependentInfo(uuid, InfoType.GM, time, gameMode, worldName));
plugin.addToProcessQueue(new PlaytimeDependentInfo(uuid, InfoType.GM, time, gameMode, worldName));
}
}

19
Plan/src/main/java/com/djrapitops/plan/data/listeners/PlanPlayerListener.java
View File

@ -6,7 +6,7 @@ import com.djrapitops.plugin.utilities.player.Gamemode;
import com.djrapitops.plugin.utilities.player.IPlayer;
import main.java.com.djrapitops.plan.Plan;
import main.java.com.djrapitops.plan.data.UserData;
import main.java.com.djrapitops.plan.data.cache.DataCacheHandler;
import main.java.com.djrapitops.plan.data.cache.DataCache;
import main.java.com.djrapitops.plan.data.handling.info.KickInfo;
import main.java.com.djrapitops.plan.data.handling.info.LoginInfo;
import main.java.com.djrapitops.plan.data.handling.info.LogoutInfo;
@ -32,7 +32,7 @@ import java.util.UUID;
public class PlanPlayerListener implements Listener {
private final Plan plugin;
private final DataCacheHandler handler;
private final DataCache handler;
/**
* Class Constructor.
@ -80,9 +80,9 @@ public class PlanPlayerListener implements Listener {
if (isNewPlayer) {
UserData newUserData = NewPlayerCreator.createNewPlayer(iPlayer);
loginInfo.process(newUserData);
handler.newPlayer(newUserData);
// TODO Rewrite Register & Login system handler.newPlayer(newUserData);
} else {
handler.addToPool(loginInfo);
// handler.addToPool(loginInfo);
}
this.cancel();
}
@ -98,6 +98,7 @@ public class PlanPlayerListener implements Listener {
*/
@EventHandler(priority = EventPriority.MONITOR)
public void onPlayerQuit(PlayerQuitEvent event) {
// TODO Rewrite Logout system
Player player = event.getPlayer();
UUID uuid = player.getUniqueId();
handler.endSession(uuid);
@ -107,8 +108,7 @@ public class PlanPlayerListener implements Listener {
Gamemode gm = Gamemode.wrap(player.getGameMode());
String worldName = player.getWorld().getName();
handler.addToPool(new LogoutInfo(uuid, time, banned, gm.name(), handler.getSession(uuid), worldName));
handler.saveCachedData(uuid);
plugin.addToProcessQueue(new LogoutInfo(uuid, time, banned, gm.name(), worldName));
}
/**
@ -133,9 +133,8 @@ public class PlanPlayerListener implements Listener {
boolean banned = player.isBanned();
Gamemode gm = Gamemode.wrap(player.getGameMode());
String worldName = player.getWorld().getName();
handler.addToPool(new LogoutInfo(uuid, time, banned, gm.name(), handler.getSession(uuid), worldName));
handler.addToPool(new KickInfo(uuid));
handler.saveCachedData(uuid);
//TODO String geoLocation = GeolocationCacheHandler.getCountry(ip.getHostAddress());
plugin.addToProcessQueue(new LogoutInfo(uuid, time, banned, gm.name(), worldName));
plugin.addToProcessQueue(new KickInfo(uuid));
}
}

7
Plan/src/main/java/com/djrapitops/plan/data/listeners/PlanWorldChangeListener.java
View File

@ -1,7 +1,6 @@
package main.java.com.djrapitops.plan.data.listeners;
import main.java.com.djrapitops.plan.Plan;
import main.java.com.djrapitops.plan.data.cache.DataCacheHandler;
import main.java.com.djrapitops.plan.data.handling.info.InfoType;
import main.java.com.djrapitops.plan.data.handling.info.PlaytimeDependentInfo;
import main.java.com.djrapitops.plan.utilities.MiscUtils;
@ -14,10 +13,10 @@ import org.bukkit.event.player.PlayerChangedWorldEvent;
import java.util.UUID;
public class PlanWorldChangeListener implements Listener {
private final DataCacheHandler handler;
private final Plan plugin;
public PlanWorldChangeListener(Plan plugin) {
this.handler = plugin.getHandler();
this.plugin = plugin;
}
@EventHandler(priority = EventPriority.MONITOR)
@ -34,6 +33,6 @@ public class PlanWorldChangeListener implements Listener {
String gameMode = p.getGameMode().name();
long time = MiscUtils.getTime();
handler.addToPool(new PlaytimeDependentInfo(uuid, InfoType.WORLD, time, gameMode, worldName));
plugin.addToProcessQueue(new PlaytimeDependentInfo(uuid, InfoType.WORLD, time, gameMode, worldName));
}
}

4
Plan/src/main/java/com/djrapitops/plan/data/listeners/TPSCountTimer.java
View File

@ -5,7 +5,7 @@ import com.djrapitops.plugin.task.AbsRunnable;
import main.java.com.djrapitops.plan.Log;
import main.java.com.djrapitops.plan.Plan;
import main.java.com.djrapitops.plan.data.TPS;
import main.java.com.djrapitops.plan.data.cache.DataCacheHandler;
import main.java.com.djrapitops.plan.data.cache.DataCache;
import main.java.com.djrapitops.plan.utilities.MiscUtils;
import main.java.com.djrapitops.plan.utilities.analysis.MathUtils;
import org.bukkit.World;
@ -23,7 +23,7 @@ import java.util.List;
public class TPSCountTimer extends AbsRunnable {
private final Plan plugin;
private final DataCacheHandler handler;
private final DataCache handler;
private final List<TPS> history;
private long lastCheckNano;

14
Plan/src/main/java/com/djrapitops/plan/data/time/WorldTimes.java
View File

@ -43,11 +43,21 @@ public class WorldTimes {
worldTimes.put(worldName, new GMTimes(gameMode, changeTime));
}
/**
* Updates the state at the end of the session.
* Does not change world or GameMode.
*
* @param changeTime epoch ms session ended.
*/
public void updateState(long changeTime) {
updateState(currentWorld, currentGamemode, changeTime);
}
/**
* Updates the time status to match the new state.
*
* @param worldName World name of the world swapped to.
* @param gameMode GameMode name of the gm swapped to.
* @param worldName World name of the world swapped to.
* @param gameMode GameMode name of the gm swapped to.
* @param changeTime Epoch ms the change occurred.
*/
public void updateState(String worldName, String gameMode, long changeTime) {

43
Plan/src/main/java/com/djrapitops/plan/database/Database.java
View File

@ -2,7 +2,6 @@ package main.java.com.djrapitops.plan.database;
import main.java.com.djrapitops.plan.Plan;
import main.java.com.djrapitops.plan.data.UserData;
import main.java.com.djrapitops.plan.data.cache.DBCallableProcessor;
import main.java.com.djrapitops.plan.database.tables.*;
import java.sql.SQLException;
@ -111,32 +110,6 @@ public abstract class Database {
return false;
}
/**
* Used to give Database processors to call with UserData after they have
* been fetched from the database.
* <p>
* This method is a shortcut method for multiple parameters.
*
* @param uuid UUID of the player.
* @param processors Processors to call with the UserData after the fetch is
* complete.
* @throws SQLException If a database error occurs.
*/
public void giveUserDataToProcessors(UUID uuid, DBCallableProcessor... processors) throws SQLException {
giveUserDataToProcessors(uuid, Arrays.asList(processors));
}
/**
* Used to give Database processors to call with UserData after they have
* been fetched from the database.
*
* @param uuid UUID of the player.
* @param processors Processors to call with the UserData after the fetch is
* complete.
* @throws SQLException If a database error occurs.
*/
public abstract void giveUserDataToProcessors(UUID uuid, Collection<DBCallableProcessor> processors) throws SQLException;
/**
* Used to get all UserData for multiple UUIDs.
* <p>
@ -148,22 +121,6 @@ public abstract class Database {
*/
public abstract List<UserData> getUserDataForUUIDS(Collection<UUID> uuids) throws SQLException;
/**
* Used to save UserData object of a user.
*
* @param data UserData of the Player.
* @throws SQLException If a database error occurs.
*/
public abstract void saveUserData(UserData data) throws SQLException;
/**
* Used to save UserData object of multiple users.
*
* @param data Collection of UserData objects.
* @throws SQLException If a database error occurs.
*/
public abstract void saveMultipleUserData(Collection<UserData> data) throws SQLException;
/**
* Check if the user is saved in the database.
*

314
Plan/src/main/java/com/djrapitops/plan/database/databases/SQLDB.java
View File

@ -6,12 +6,9 @@ import main.java.com.djrapitops.plan.Plan;
import main.java.com.djrapitops.plan.data.KillData;
import main.java.com.djrapitops.plan.data.SessionData;
import main.java.com.djrapitops.plan.data.UserData;
import main.java.com.djrapitops.plan.data.cache.DBCallableProcessor;
import main.java.com.djrapitops.plan.data.time.WorldTimes;
import main.java.com.djrapitops.plan.database.Database;
import main.java.com.djrapitops.plan.database.tables.*;
import main.java.com.djrapitops.plan.utilities.Benchmark;
import main.java.com.djrapitops.plan.utilities.FormatUtils;
import main.java.com.djrapitops.plan.utilities.MiscUtils;
import java.net.InetAddress;
@ -19,7 +16,6 @@ import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
/**
@ -103,7 +99,6 @@ public abstract class SQLDB extends Database {
if (!checkConnection()) {
return false;
}
convertBukkitDataToDB();
clean();
return true;
} catch (SQLException e) {
@ -186,40 +181,6 @@ public abstract class SQLDB extends Database {
}
}
/**
*
*/
public void convertBukkitDataToDB() {
plugin.getRunnableFactory().createNew(new AbsRunnable("BukkitDataConversionTask") {
@Override
public void run() {
try {
Benchmark.start("Convert BukkitData to DB data");
Log.debug("Database", "Bukkit Data Conversion");
Set<UUID> uuids = usersTable.getSavedUUIDs();
uuids.removeAll(usersTable.getContainsBukkitData(uuids));
if (uuids.isEmpty()) {
Log.debug("Database", "No conversion necessary.");
return;
}
Log.info("Beginning Bukkit Data -> DB Conversion for " + uuids.size() + " players");
int id = plugin.getBootAnalysisTaskID();
if (id != -1) {
Log.info("Analysis | Cancelled Boot Analysis Due to conversion.");
plugin.getServer().getScheduler().cancelTask(id);
}
saveMultipleUserData(getUserDataForUUIDS(uuids));
Log.info("Conversion complete, took: " + FormatUtils.formatTimeAmount(Benchmark.stop("Database", "Convert BukkitData to DB data")) + " ms");
} catch (SQLException ex) {
Log.toLog(this.getClass().getName(), ex);
} finally {
setAvailable();
this.cancel();
}
}
}).runTaskAsynchronously();
}
/**
* @return
*/
@ -335,231 +296,6 @@ public abstract class SQLDB extends Database {
}
}
/**
* @param uuid
* @param processors
* @throws SQLException
*/
@Override
public void giveUserDataToProcessors(UUID uuid, Collection<DBCallableProcessor> processors) throws SQLException {
Benchmark.start("Give userdata to processors");
try {
checkConnection();
} catch (Exception e) {
Log.toLog(this.getClass().getName(), e);
return;
}
// Check if user is in the database
if (!wasSeenBefore(uuid)) {
return;
}
setStatus("Get single userdata for " + uuid);
// Get the data
UserData data = usersTable.getUserData(uuid);
int userId = usersTable.getUserId(uuid);
List<String> nicknames = nicknamesTable.getNicknames(userId);
data.addNicknames(nicknames);
if (!nicknames.isEmpty()) {
data.setLastNick(nicknames.get(nicknames.size() - 1));
}
List<InetAddress> ips = ipsTable.getIPAddresses(userId);
data.addIpAddresses(ips);
Map<String, Long> worldTimes = worldTimesTable.getWorldTimes(userId);
WorldTimes worldT = data.getWorldTimes();
// worldT.setTimes(worldTimes); //TODO
// if (worldT.getLastStateChange() == 0) {
// worldT.setLastStateChange(data.getPlayTime());
// }
List<SessionData> sessions = sessionsTable.getSessionData(userId);
data.addSessions(sessions);
data.setPlayerKills(killsTable.getPlayerKills(userId));
processors.forEach(processor -> processor.process(data));
Benchmark.stop("Database", "Give userdata to processors");
setAvailable();
}
/**
* @param uuidsCol
* @return
* @throws SQLException
*/
@Override
public List<UserData> getUserDataForUUIDS(Collection<UUID> uuidsCol) throws SQLException {
if (uuidsCol == null || uuidsCol.isEmpty()) {
return new ArrayList<>();
}
setStatus("Get userdata (multiple) for: " + uuidsCol.size());
Benchmark.start("Get UserData for " + uuidsCol.size());
Map<UUID, Integer> userIds = usersTable.getAllUserIds();
Set<UUID> remove = uuidsCol.stream()
.filter(uuid -> !userIds.containsKey(uuid))
.collect(Collectors.toSet());
List<UUID> uuids = new ArrayList<>(uuidsCol);
Log.debug("Database", "Data not found for: " + remove.size());
uuids.removeAll(remove);
Benchmark.start("Create UserData objects for " + userIds.size());
List<UserData> data = usersTable.getUserData(new ArrayList<>(uuids));
Benchmark.stop("Database", "Create UserData objects for " + userIds.size());
if (data.isEmpty()) {
return data;
}
Map<Integer, UUID> idUuidRel = userIds.entrySet().stream().collect(Collectors.toMap(Map.Entry::getValue, Map.Entry::getKey));
List<Integer> ids = userIds.entrySet().stream().filter(e -> uuids.contains(e.getKey())).map(Map.Entry::getValue).collect(Collectors.toList());
Log.debug("Database", "Using IDs: " + ids.size());
Map<Integer, List<String>> nicknames = nicknamesTable.getNicknames(ids);
Map<Integer, Set<InetAddress>> ipList = ipsTable.getIPList(ids);
Map<Integer, List<KillData>> playerKills = killsTable.getPlayerKills(ids, idUuidRel);
Map<Integer, List<SessionData>> sessionData = sessionsTable.getSessionData(ids);
Map<Integer, Map<String, Long>> worldTimes = worldTimesTable.getWorldTimes(ids);
Log.debug("Database",
"Data found for:",
" UUIDs: " + uuids.size(),
" IDs: " + userIds.size(),
" UserData: " + data.size(),
" Nicknames: " + nicknames.size(),
" IPs: " + ipList.size(),
" Kills: " + playerKills.size(),
" Sessions: " + sessionData.size(),
" World Times: " + worldTimes.size()
);
for (UserData uData : data) {
UUID uuid = uData.getUuid();
Integer id = userIds.get(uuid);
uData.addIpAddresses(ipList.get(id));
List<String> userNicks = nicknames.get(id);
uData.addNicknames(userNicks);
if (!userNicks.isEmpty()) {
uData.setLastNick(userNicks.get(userNicks.size() - 1));
}
uData.addSessions(sessionData.get(id));
uData.setPlayerKills(playerKills.get(id));
WorldTimes worldT = uData.getWorldTimes();
// worldT.setTimes(worldTimes.get(id)); //TODO
// if (worldT.getLastStateChange() == 0) {
// worldT.setLastStateChange(uData.getPlayTime());
// }
}
Benchmark.stop("Database", "Get UserData for " + uuidsCol.size());
setAvailable();
return data;
}
/**
* @param data
* @throws SQLException
*/
@Override
public void saveMultipleUserData(Collection<UserData> data) throws SQLException {
if (data == null || data.isEmpty()) {
return;
}
Benchmark.start("Save multiple Userdata");
data.removeIf(Objects::isNull);
checkConnection();
setStatus("Save userdata (multiple) for " + data.size());
usersTable.saveUserDataInformationBatch(data);
// Transform to map
Map<UUID, UserData> userDatas = data.stream()
.collect(Collectors.toMap(UserData::getUuid, Function.identity()));
// Get UserIDs
Map<UUID, Integer> userIds = usersTable.getAllUserIds();
// Create empty data sets
Map<Integer, Set<String>> nicknames = new HashMap<>();
Map<Integer, String> lastNicks = new HashMap<>();
Map<Integer, Set<InetAddress>> ips = new HashMap<>();
Map<Integer, List<KillData>> kills = new HashMap<>();
Map<Integer, UUID> uuids = userIds.entrySet().stream().collect(Collectors.toMap(Map.Entry::getValue, Map.Entry::getKey));
Map<Integer, List<SessionData>> sessions = new HashMap<>();
Map<Integer, Map<String, Long>> gmTimes = new HashMap<>();
Map<Integer, Map<String, Long>> worldTimes = new HashMap<>();
// Put in data set
// List<String> worldNames = data.stream() //TODO
// .map(UserData::getWorldTimes)
// .map(WorldTimes::getTimes)
// .map(Map::keySet)
// .flatMap(Collection::stream)
// .distinct()
// .collect(Collectors.toList());
for (Map.Entry<UUID, UserData> entrySet : userDatas.entrySet()) {
UUID uuid = entrySet.getKey();
UserData uData = entrySet.getValue();
Integer id = userIds.get(uuid);
if (id == -1) {
Log.debug("Database", "User not seen before, saving last: " + uuid);
continue;
}
uData.access();
nicknames.put(id, new HashSet<>(uData.getNicknames()));
lastNicks.put(id, uData.getLastNick());
ips.put(id, new HashSet<>(uData.getIps()));
kills.put(id, new ArrayList<>(uData.getPlayerKills()));
sessions.put(id, new ArrayList<>(uData.getSessions()));
gmTimes.put(id, new HashMap<>(uData.getGmTimes().getTimes()));
// TODO worldTimes.put(id, new HashMap<>(uData.getWorldTimes().getTimes()));
}
// Save
nicknamesTable.saveNickLists(nicknames, lastNicks);
ipsTable.saveIPList(ips);
killsTable.savePlayerKills(kills, uuids);
sessionsTable.saveSessionData(sessions);
// TODO worldTable.saveWorlds(worldNames);
worldTimesTable.saveWorldTimes(worldTimes);
commit();
userDatas.values().stream()
.filter(Objects::nonNull)
.filter(UserData::isAccessed)
.forEach(UserData::stopAccessing);
Benchmark.stop("Database", "Save multiple Userdata");
setAvailable();
}
/**
* @param data
* @throws SQLException
*/
@Override
public void saveUserData(UserData data) throws SQLException {
if (data == null) {
return;
}
UUID uuid = data.getUuid();
if (uuid == null) {
return;
}
Log.debug("Database", "Save userdata: " + uuid);
Benchmark.start("Save Single UserData");
checkConnection();
data.access();
usersTable.saveUserDataInformation(data);
int userId = usersTable.getUserId(uuid.toString());
sessionsTable.saveSessionData(userId, new ArrayList<>(data.getSessions()));
nicknamesTable.saveNickList(userId, new HashSet<>(data.getNicknames()), data.getLastNick());
ipsTable.saveIPList(userId, new HashSet<>(data.getIps()));
killsTable.savePlayerKills(userId, new ArrayList<>(data.getPlayerKills()));
// TODO worldTable.saveWorlds(new HashSet<>(data.getWorldTimes().getTimes().keySet()));
// worldTimesTable.saveWorldTimes(userId, data.getWorldTimes().getTimes());
data.stopAccessing();
commit();
Benchmark.stop("Database", "Save Single UserData");
setAvailable();
}
/**
*
*/
@ -601,6 +337,56 @@ public abstract class SQLDB extends Database {
return success;
}
@Override
public List<UserData> getUserDataForUUIDS(Collection<UUID> uuidsCol) throws SQLException {
if (uuidsCol == null || uuidsCol.isEmpty()) {
return new ArrayList<>();
}
setStatus("Get userdata (multiple) for: " + uuidsCol.size());
Benchmark.start("Get UserData for " + uuidsCol.size());
Map<UUID, Integer> userIds = usersTable.getAllUserIds();
Set<UUID> remove = uuidsCol.stream()
.filter(uuid -> !userIds.containsKey(uuid))
.collect(Collectors.toSet());
List<UUID> uuids = new ArrayList<>(uuidsCol);
Log.debug("Database", "Data not found for: " + remove.size());
uuids.removeAll(remove);
Benchmark.start("Create UserData objects for " + userIds.size());
List<UserData> data = usersTable.getUserData(uuids);
Benchmark.stop("Database", "Create UserData objects for " + userIds.size());
if (data.isEmpty()) {
return data;
}
Map<Integer, UUID> idUuidRel = userIds.entrySet().stream().collect(Collectors.toMap(Map.Entry::getValue, Map.Entry::getKey));
List<Integer> ids = userIds.entrySet().stream().filter(e -> uuids.contains(e.getKey())).map(Map.Entry::getValue).collect(Collectors.toList());
Log.debug("Database", "Using IDs: " + ids.size());
Map<Integer, List<String>> nicknames = nicknamesTable.getNicknames(ids);
Map<Integer, Set<InetAddress>> ipList = ipsTable.getIPList(ids);
Map<Integer, List<KillData>> playerKills = killsTable.getPlayerKills(ids, idUuidRel);
Map<Integer, List<SessionData>> sessionData = sessionsTable.getSessionData(ids);
Map<Integer, Map<String, Long>> worldTimes = worldTimesTable.getWorldTimes(ids);
Log.debug("Database",
"Data found for:",
" UUIDs: " + uuids.size(),
" IDs: " + userIds.size(),
" UserData: " + data.size(),
" Nicknames: " + nicknames.size(),
" IPs: " + ipList.size(),
" Kills: " + playerKills.size(),
" Sessions: " + sessionData.size(),
" World Times: " + worldTimes.size()
);
for (UserData uData : data) {
// TODO add extra data
}
Benchmark.stop("Database", "Get UserData for " + uuidsCol.size());
setAvailable();
return data;
}
/**
* @return
*/

4
Plan/src/main/java/com/djrapitops/plan/database/tables/SessionsTable.java
View File

@ -75,7 +75,7 @@ public class SessionsTable extends UserIDTable {
set = statement.executeQuery();
List<SessionData> sessions = new ArrayList<>();
while (set.next()) {
sessions.add(new SessionData(set.getLong(columnSessionStart), set.getLong(columnSessionEnd)));
// sessions.add(new SessionData(set.getLong(columnSessionStart), set.getLong(columnSessionEnd)));
}
set.close();
statement.close();
@ -169,7 +169,7 @@ public class SessionsTable extends UserIDTable {
long sessionStart = set.getLong(columnSessionStart);
long sessionEnd = set.getLong(columnSessionEnd);
sessions.get(id).add(new SessionData(sessionStart, sessionEnd));
// sessions.get(id).add(new SessionData(sessionStart, sessionEnd));
}
return sessions;

545
Plan/src/main/java/com/djrapitops/plan/database/tables/UsersTable.java
View File

@ -1,24 +1,16 @@
package main.java.com.djrapitops.plan.database.tables;
import com.djrapitops.plugin.utilities.Verify;
import com.djrapitops.plugin.utilities.player.Fetch;
import main.java.com.djrapitops.plan.Log;
import main.java.com.djrapitops.plan.data.UserData;
import main.java.com.djrapitops.plan.data.time.GMTimes;
import main.java.com.djrapitops.plan.data.time.WorldTimes;
import main.java.com.djrapitops.plan.database.DBUtils;
import main.java.com.djrapitops.plan.database.databases.SQLDB;
import main.java.com.djrapitops.plan.database.sql.Sql;
import main.java.com.djrapitops.plan.database.sql.TableSqlParser;
import main.java.com.djrapitops.plan.utilities.Benchmark;
import main.java.com.djrapitops.plan.utilities.uuid.UUIDUtility;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
/**
* @author Rsl1122
@ -27,23 +19,36 @@ public class UsersTable extends Table {
private final String columnID;
private final String columnUUID;
@Deprecated private final String columnGeolocation;
@Deprecated private final String columnLastGM;
@Deprecated private final String columnLastGMSwapTime;
@Deprecated private final String columnPlayTime;
@Deprecated private final String columnLoginTimes;
@Deprecated private final String columnLastPlayed;
@Deprecated private final String columnDeaths;
@Deprecated private final String columnMobKills;
@Deprecated
private final String columnGeolocation;
@Deprecated
private final String columnLastGM;
@Deprecated
private final String columnLastGMSwapTime;
@Deprecated
private final String columnPlayTime;
@Deprecated
private final String columnLoginTimes;
@Deprecated
private final String columnLastPlayed;
@Deprecated
private final String columnDeaths;
@Deprecated
private final String columnMobKills;
private final String columnRegistered;
private final String columnName;
//TODO Server Specific Table (Also has registered on it)
@Deprecated private final String columnOP;
@Deprecated private final String columnBanned;
@Deprecated
private final String columnOP;
@Deprecated
private final String columnBanned;
//
@Deprecated private final String columnContainsBukkitData;
@Deprecated private final String columnLastWorldSwapTime;
@Deprecated private final String columnLastWorld;
@Deprecated
private final String columnContainsBukkitData;
@Deprecated
private final String columnLastWorldSwapTime;
@Deprecated
private final String columnLastWorld;
/**
* @param db
@ -252,70 +257,6 @@ public class UsersTable extends Table {
}
}
/**
* @param uuid
* @return
* @throws SQLException
*/
public UserData getUserData(UUID uuid) throws SQLException {
boolean containsBukkitData = getContainsBukkitData(uuid);
UserData data = null;
if (containsBukkitData) {
data = getUserDataForKnown(uuid);
}
if (data == null) {
data = new UserData(Fetch.getIOfflinePlayer(uuid));
addUserInformationToUserData(data);
}
return data;
}
private boolean getContainsBukkitData(UUID uuid) throws SQLException {
PreparedStatement statement = null;
ResultSet set = null;
boolean containsBukkitData = false;
try {
statement = prepareStatement("SELECT " + columnContainsBukkitData + " FROM " + tableName + " WHERE (" + columnUUID + "=?)");
statement.setString(1, uuid.toString());
set = statement.executeQuery();
while (set.next()) {
containsBukkitData = set.getBoolean(columnContainsBukkitData);
}
} finally {
close(statement);
close(set);
}
return containsBukkitData;
}
/**
* @param uuids
* @return
* @throws SQLException
*/
public List<UserData> getUserData(Collection<UUID> uuids) throws SQLException {
Benchmark.start("Get UserInfo Multiple");
List<UUID> containsBukkitData = getContainsBukkitData(uuids);
List<UserData> datas = new ArrayList<>();
datas.addAll(getUserDataForKnown(containsBukkitData));
uuids.removeAll(containsBukkitData);
if (!uuids.isEmpty()) {
List<UserData> noBukkitData = new ArrayList<>();
Benchmark.start("Create UserData objects for No BukkitData players");
for (UUID uuid : uuids) {
UserData uData = new UserData(Fetch.getIOfflinePlayer(uuid));
noBukkitData.add(uData);
}
Benchmark.stop("Database", "Create UserData objects for No BukkitData players");
addUserInformationToUserData(noBukkitData);
datas.addAll(noBukkitData);
}
Benchmark.stop("Database", "Get UserInfo Multiple");
return datas;
}
/**
* @param uuids
* @return
@ -346,435 +287,6 @@ public class UsersTable extends Table {
return containsBukkitData;
}
private UserData getUserDataForKnown(UUID uuid) throws SQLException {
PreparedStatement statement = null;
ResultSet set = null;
try {
statement = prepareStatement("SELECT * FROM " + tableName + " WHERE (" + columnUUID + "=?)");
statement.setString(1, uuid.toString());
set = statement.executeQuery();
if (set.next()) {
String gm = set.getString(columnLastGM);
boolean op = set.getBoolean(columnOP);
boolean banned = set.getBoolean(columnBanned);
String name = set.getString(columnName);
long registered = set.getLong(columnRegistered);
UserData data = new UserData(uuid, registered, op, gm, name, false);
data.setBanned(banned);
data.setGeolocation(set.getString(columnGeolocation));
data.getGmTimes().setLastStateChange(set.getLong(columnLastGMSwapTime));
long playTime = set.getLong(columnPlayTime);
data.setPlayTime(playTime);
data.setLoginTimes(set.getInt(columnLoginTimes));
data.setLastPlayed(set.getLong(columnLastPlayed));
data.setDeaths(set.getInt(columnDeaths));
data.setMobKills(set.getInt(columnMobKills));
WorldTimes worldTimes = data.getWorldTimes();
// TODO worldTimes.setLastStateChange(set.getLong(columnLastWorldSwapTime));
// String lastWorld = set.getString(columnLastWorld);
// if (!"Unknown".equals(lastWorld)) {
// worldTimes.setState(lastWorld);
// } else {
// worldTimes.setLastStateChange(playTime);
// }
return data;
}
} finally {
close(set);
close(statement);
}
return null;
}
private List<UserData> getUserDataForKnown(Collection<UUID> uuids) throws SQLException {
PreparedStatement statement = null;
ResultSet set = null;
List<UserData> datas = new ArrayList<>();
try {
statement = prepareStatement("SELECT * FROM " + tableName);
set = statement.executeQuery();
while (set.next()) {
String uuidS = set.getString(columnUUID);
UUID uuid = UUID.fromString(uuidS);
if (!uuids.contains(uuid)) {
continue;
}
String gm = set.getString(columnLastGM);
boolean op = set.getBoolean(columnOP);
boolean banned = set.getBoolean(columnBanned);
String name = set.getString(columnName);
long registered = set.getLong(columnRegistered);
UserData data = new UserData(uuid, registered, op, gm, name, false);
data.setBanned(banned);
data.setGeolocation(set.getString(columnGeolocation));
data.getGmTimes().setLastStateChange(set.getLong(columnLastGMSwapTime));
long playTime = set.getLong(columnPlayTime);
data.setPlayTime(playTime);
data.setLoginTimes(set.getInt(columnLoginTimes));
data.setLastPlayed(set.getLong(columnLastPlayed));
data.setDeaths(set.getInt(columnDeaths));
data.setMobKills(set.getInt(columnMobKills));
WorldTimes worldTimes = data.getWorldTimes();
// TODO worldTimes.setLastStateChange(set.getLong(columnLastWorldSwapTime));
// String lastWorld = set.getString(columnLastWorld);
// if (!"Unknown".equals(lastWorld)) {
// worldTimes.setState(lastWorld);
// } else {
// worldTimes.setLastStateChange(playTime);
// }
datas.add(data);
}
} finally {
close(set);
close(statement);
}
return datas;
}
/**
* @param data
* @throws SQLException
*/
public void addUserInformationToUserData(UserData data) throws SQLException {
PreparedStatement statement = null;
ResultSet set = null;
try {
statement = prepareStatement("SELECT * FROM " + tableName + " WHERE (" + columnUUID + "=?)");
statement.setString(1, data.getUuid().toString());
set = statement.executeQuery();
while (set.next()) {
data.setGeolocation(set.getString(columnGeolocation));
GMTimes gmTimes = data.getGmTimes();
gmTimes.setState(set.getString(columnLastGM));
gmTimes.setLastStateChange(set.getLong(columnLastGMSwapTime));
long playTime = set.getLong(columnPlayTime);
data.setPlayTime(playTime);
data.setLoginTimes(set.getInt(columnLoginTimes));
data.setLastPlayed(set.getLong(columnLastPlayed));
data.setDeaths(set.getInt(columnDeaths));
data.setMobKills(set.getInt(columnMobKills));
WorldTimes worldTimes = data.getWorldTimes();
// TODO worldTimes.setLastStateChange(set.getLong(columnLastWorldSwapTime));
// String lastWorld = set.getString(columnLastWorld);
// if (!"Unknown".equals(lastWorld)) {
// worldTimes.setState(lastWorld);
// } else {
// worldTimes.setLastStateChange(playTime);
// }
}
} finally {
close(set);
close(statement);
}
}
/**
* @param data
* @throws SQLException
*/
public void addUserInformationToUserData(List<UserData> data) throws SQLException {
PreparedStatement statement = null;
ResultSet set = null;
try {
Map<UUID, UserData> userDatas = data.stream().collect(Collectors.toMap(UserData::getUuid, Function.identity()));
statement = prepareStatement("SELECT * FROM " + tableName);
set = statement.executeQuery();
while (set.next()) {
String uuidS = set.getString(columnUUID);
UUID uuid = UUID.fromString(uuidS);
if (!userDatas.keySet().contains(uuid)) {
continue;
}
UserData uData = userDatas.get(uuid);
uData.setGeolocation(set.getString(columnGeolocation));
long playTime = set.getLong(columnPlayTime);
uData.setPlayTime(playTime);
uData.setLoginTimes(set.getInt(columnLoginTimes));
uData.setLastPlayed(set.getLong(columnLastPlayed));
uData.setDeaths(set.getInt(columnDeaths));
uData.setMobKills(set.getInt(columnMobKills));
GMTimes gmTimes = uData.getGmTimes();
gmTimes.setState(set.getString(columnLastGM));
gmTimes.setLastStateChange(set.getLong(columnLastGMSwapTime));
WorldTimes worldTimes = uData.getWorldTimes();
// TODO worldTimes.setLastStateChange(set.getLong(columnLastWorldSwapTime));
// String lastWorld = set.getString(columnLastWorld);
// if (!"Unknown".equals(lastWorld)) {
// worldTimes.setState(lastWorld);
// } else {
// worldTimes.setLastStateChange(playTime);
// }
}
} finally {
close(set);
close(statement);
}
}
/**
* @param data
* @throws SQLException
*/
public void saveUserDataInformation(UserData data) throws SQLException {
PreparedStatement statement = null;
try {
UUID uuid = data.getUuid();
int userId = getUserId(uuid);
int update = 0;
if (userId != -1) {
String sql = getUpdateStatement();
statement = prepareStatement(sql);
statement.setString(1, data.getGeolocation());
GMTimes gmTimes = data.getGmTimes();
statement.setString(2, gmTimes.getState());
statement.setLong(3, gmTimes.getLastStateChange());
statement.setLong(4, data.getPlayTime());
statement.setInt(5, data.getLoginTimes());
statement.setLong(6, data.getLastPlayed());
statement.setInt(7, data.getDeaths());
statement.setInt(8, data.getMobKills());
statement.setBoolean(9, data.getName() != null);
statement.setBoolean(10, data.isOp());
statement.setBoolean(11, data.isBanned());
statement.setString(12, data.getName());
statement.setLong(13, data.getRegistered());
WorldTimes worldTimes = data.getWorldTimes();
// TODO statement.setString(14, worldTimes.getState());
// statement.setLong(15, worldTimes.getLastStateChange());
statement.setString(16, uuid.toString());
update = statement.executeUpdate();
}
if (update == 0) {
close(statement);
statement = prepareStatement(getInsertStatement());
statement.setString(1, uuid.toString());
statement.setString(2, data.getGeolocation());
GMTimes gmTimes = data.getGmTimes();
statement.setString(3, gmTimes.getState());
statement.setLong(4, gmTimes.getLastStateChange());
statement.setLong(5, data.getPlayTime());
statement.setInt(6, data.getLoginTimes());
statement.setLong(7, data.getLastPlayed());
statement.setInt(8, data.getDeaths());
statement.setInt(9, data.getMobKills());
statement.setBoolean(10, data.getName() != null);
statement.setBoolean(11, data.isOp());
statement.setBoolean(12, data.isBanned());
statement.setString(13, data.getName());
statement.setLong(14, data.getRegistered());
WorldTimes worldTimes = data.getWorldTimes();
// TODO statement.setString(15, worldTimes.getState());
// statement.setLong(16, worldTimes.getLastStateChange());
statement.execute();
}
} finally {
close(statement);
}
}
private boolean tableHasV4Columns() {
if (usingMySQL) {
return false;
} else {
PreparedStatement statement = null;
ResultSet set = null;
try {
try {
statement = prepareStatement("SELECT age FROM " + tableName + " LIMIT 1");
set = statement.executeQuery();
Log.debug("Database", "UsersTable has V4 columns.");
return true;
} catch (SQLException e) {
return false;
}
} finally {
close(set, statement);
}
}
}
private String getInsertStatement() {
final boolean hasV4Columns = tableHasV4Columns();
String v4rows = hasV4Columns ? "age, gender, " : "";
String v4values = hasV4Columns ? "-1, Deprecated, " : "";
return "INSERT INTO " + tableName + " ("
+ v4rows
+ columnUUID + ", "
+ columnGeolocation + ", "
+ columnLastGM + ", "
+ columnLastGMSwapTime + ", "
+ columnPlayTime + ", "
+ columnLoginTimes + ", "
+ columnLastPlayed + ", "
+ columnDeaths + ", "
+ columnMobKills + ", "
+ columnContainsBukkitData + ", "
+ columnOP + ", "
+ columnBanned + ", "
+ columnName + ", "
+ columnRegistered + ", "
+ columnLastWorld + ", "
+ columnLastWorldSwapTime
+ ") VALUES (" + v4values + "?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
}
private String getUpdateStatement() {
final boolean hasV4Columns = tableHasV4Columns();
String v4rows = hasV4Columns ? "age=-1, gender='Deprecated', " : "";
return "UPDATE " + tableName + " SET "
+ v4rows
+ columnGeolocation + "=?, "
+ columnLastGM + "=?, "
+ columnLastGMSwapTime + "=?, "
+ columnPlayTime + "=?, "
+ columnLoginTimes + "=?, "
+ columnLastPlayed + "=?, "
+ columnDeaths + "=?, "
+ columnMobKills + "=?, "
+ columnContainsBukkitData + "=?, "
+ columnOP + "=?, "
+ columnBanned + "=?, "
+ columnName + "=?, "
+ columnRegistered + "=?, "
+ columnLastWorld + "=?, "
+ columnLastWorldSwapTime + "=? "
+ "WHERE " + columnUUID + "=?";
}
/**
* @param data
* @throws SQLException
*/
public void saveUserDataInformationBatch(Collection<UserData> data) throws SQLException {
Benchmark.start("Save UserInfo multiple");
try {
List<UserData> newUserdata = updateExistingUserData(data);
Benchmark.start("Insert new UserInfo multiple");
List<List<UserData>> batches = DBUtils.splitIntoBatches(newUserdata);
batches
.forEach(batch -> {
try {
insertNewUserData(batch);
} catch (SQLException e) {
Log.toLog("UsersTable.saveUserDataInformationBatch", e);
}
});
Benchmark.stop("Database", "Insert new UserInfo multiple");
} finally {
Benchmark.stop("Database", "Save UserInfo multiple");
}
}
private void insertNewUserData(Collection<UserData> data) throws SQLException {
if (data.isEmpty()) {
return;
}
PreparedStatement statement = null;
try {
statement = prepareStatement(getInsertStatement());
for (UserData uData : data) {
UUID uuid = uData.getUuid();
statement.setString(1, uuid.toString());
statement.setString(2, uData.getGeolocation());
GMTimes gmTimes = uData.getGmTimes();
statement.setString(3, gmTimes.getState());
statement.setLong(4, gmTimes.getLastStateChange());
statement.setLong(5, uData.getPlayTime());
statement.setInt(6, uData.getLoginTimes());
statement.setLong(7, uData.getLastPlayed());
statement.setInt(8, uData.getDeaths());
statement.setInt(9, uData.getMobKills());
statement.setBoolean(10, uData.getName() != null);
statement.setBoolean(11, uData.isOp());
statement.setBoolean(12, uData.isBanned());
statement.setString(13, uData.getName());
statement.setLong(14, uData.getRegistered());
WorldTimes worldTimes = uData.getWorldTimes();
// TODO statement.setString(15, worldTimes.getState());
// statement.setLong(16, worldTimes.getLastStateChange());
statement.addBatch();
}
statement.executeBatch();
} finally {
close(statement);
}
}
private List<UserData> updateExistingUserData(Collection<UserData> data) throws SQLException {
PreparedStatement statement = null;
try {
List<UserData> newUserData = new ArrayList<>();
String sql = getUpdateStatement();
statement = prepareStatement(sql);
boolean commitRequired = false;
Set<UUID> savedUUIDs = getSavedUUIDs();
for (UserData uData : data) {
UUID uuid = null;
// Get new UUID if uuid == null
if (uData != null) {
uuid = uData.getUuid();
if (uuid == null) {
uuid = UUIDUtility.getUUIDOf(uData.getName(), db);
uData.setUuid(uuid);
}
}
boolean isNew = !savedUUIDs.contains(uuid) && !newUserData.contains(uData);
if (isNew) {
newUserData.add(uData);
}
if (!Verify.notNull(uData, uuid) || isNew) {
continue;
}
uData.access();
statement.setString(1, uData.getGeolocation());
GMTimes gmTimes = uData.getGmTimes();
statement.setString(2, gmTimes.getState());
statement.setLong(3, uData.getGmTimes().getLastStateChange());
statement.setLong(4, uData.getPlayTime());
statement.setInt(5, uData.getLoginTimes());
statement.setLong(6, uData.getLastPlayed());
statement.setInt(7, uData.getDeaths());
statement.setInt(8, uData.getMobKills());
statement.setBoolean(9, uData.getName() != null);
statement.setBoolean(10, uData.isOp());
statement.setBoolean(11, uData.isBanned());
statement.setString(12, uData.getName());
statement.setLong(13, uData.getRegistered());
WorldTimes worldTimes = uData.getWorldTimes();
// TODO statement.setString(14, worldTimes.getState());
// statement.setLong(15, worldTimes.getLastStateChange());
statement.setString(16, uuid.toString());
statement.addBatch();
uData.stopAccessing();
commitRequired = true;
}
if (commitRequired) {
statement.executeBatch();
}
return newUserData;
} finally {
close(statement);
}
}
/**
* @param uuids
* @return
@ -857,4 +369,9 @@ public class UsersTable extends Table {
close(statement);
}
}
public List<UserData> getUserData(List<UUID> uuids) {
// TODO Rewrite method for new UserData objects.
return null;
}
}

2
Plan/src/main/java/com/djrapitops/plan/locale/Locale.java
View File

@ -131,7 +131,7 @@ public class Locale {
add(Msg.ENABLE_BOOT_ANALYSIS_RUN_INFO, analysis + "Starting Boot Analysis..");
add(Msg.ENABLE_NOTIFY_EMPTY_IP, yellow + "IP in server.properties is empty & AlternativeServerIP is not used, incorrect links will be given!");
add(Msg.ENABLE_NOTIFY_NO_DATA_VIEW, yellow + "Webserver disabled but Alternative IP/TextUI not used, no way to view data!");
add(Msg.ENABLE_NOTIFY_NO_DATA_VIEW, yellow + "Webserver disabled but Alternative IP not used, no way to view data!");
add(Msg.ENABLE_NOTIFY_DISABLED_CHATLISTENER, yellow + "Chat listener disabled, nickname info inaccurate.");
add(Msg.ENABLE_NOTIFY_DISABLED_COMMANDLISTENER, yellow + "Command usage listener disabled.");
add(Msg.ENABLE_NOTIFY_DISABLED_DEATHLISTENER, yellow + "Death listener disabled, player & mob kills not recorded.");

102
Plan/src/main/java/com/djrapitops/plan/queue/DataCacheClearQueue.java
View File

@ -1,102 +0,0 @@
package main.java.com.djrapitops.plan.queue;
import com.djrapitops.plugin.utilities.Verify;
import main.java.com.djrapitops.plan.Log;
import main.java.com.djrapitops.plan.data.cache.DataCacheHandler;
import main.java.com.djrapitops.plan.locale.Locale;
import main.java.com.djrapitops.plan.locale.Msg;
import java.util.Collection;
import java.util.Objects;
import java.util.UUID;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.stream.Collectors;
/**
* This Class contains the Clear Queue Thread, which is clearing data from the DataCache.
*
* @author Rsl1122
* @since 3.0.0
*/
@Deprecated
public class DataCacheClearQueue extends Queue<UUID> {
/**
* Class constructor, starts the new Thread for clearing.
*
* @param handler current instance of DataCacheHandler.
*/
public DataCacheClearQueue(DataCacheHandler handler) {
super(new ArrayBlockingQueue<>(20000));
setup = new ClearSetup(queue, handler);
setup.go();
}
/**
* Used to schedule UserData to be cleared from the cache.
*
* @param uuid UUID of the UserData object (Player's UUID)
*/
public void scheduleForClear(UUID uuid) {
queue.add(uuid);
}
/**
* Used to schedule multiple UserData objects to be cleared from the cache.
*
* @param uuids UUIDs of the UserData object (Players' UUIDs)
*/
public void scheduleForClear(Collection<UUID> uuids) {
if (Verify.isEmpty(uuids)) {
return;
}
try {
queue.addAll(uuids.stream().filter(Objects::nonNull).collect(Collectors.toList()));
} catch (IllegalStateException e) {
Log.error(Locale.get(Msg.RUN_WARN_QUEUE_SIZE).parse("Clear Queue", 20000));
}
}
}
@Deprecated
class ClearConsumer extends Consumer<UUID> implements Runnable {
private DataCacheHandler handler;
ClearConsumer(BlockingQueue<UUID> q, DataCacheHandler handler) {
super(q, "ClearQueueConsumer");
this.handler = handler;
}
@Override
protected void consume(UUID uuid) {
if (!Verify.notNull(handler, uuid)) {
return;
}
try {
if (handler.isDataAccessed(uuid)) {
queue.add(uuid);
} else {
handler.clearFromCache(uuid);
}
// if online remove from clear list
} catch (Exception ex) {
Log.toLog(this.getClass().getName(), ex);
}
}
@Override
protected void clearVariables() {
if (handler != null) {
handler = null;
}
}
}
@Deprecated
class ClearSetup extends Setup<UUID> {
ClearSetup(BlockingQueue<UUID> q, DataCacheHandler handler) {
super(new ClearConsumer(q, handler));
}
}

98
Plan/src/main/java/com/djrapitops/plan/queue/DataCacheGetQueue.java
View File

@ -1,98 +0,0 @@
package main.java.com.djrapitops.plan.queue;
import com.djrapitops.plugin.utilities.Verify;
import main.java.com.djrapitops.plan.Log;
import main.java.com.djrapitops.plan.Plan;
import main.java.com.djrapitops.plan.data.cache.DBCallableProcessor;
import main.java.com.djrapitops.plan.database.Database;
import main.java.com.djrapitops.plan.locale.Locale;
import main.java.com.djrapitops.plan.locale.Msg;
import java.util.*;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
/**
* This Class is starts the Get Queue Thread, that fetches data from DataCache.
*
* @author Rsl1122
* @since 3.0.0
*/
@Deprecated
public class DataCacheGetQueue extends Queue<Map<UUID, List<DBCallableProcessor>>> {
/**
* Class constructor, starts the new Thread for fetching.
*
* @param plugin current instance of Plan
*/
public DataCacheGetQueue(Plan plugin) {
super(new ArrayBlockingQueue<>(20000));
setup = new GetSetup(queue, plugin.getDB());
setup.go();
}
/**
* Schedules UserData objects to be get for the given processors.
*
* @param uuid UUID of the player whose UserData object is fetched.
* @param processors Processors which process-method will be called after
* fetch is complete, with the UserData object.
*/
public void scheduleForGet(UUID uuid, DBCallableProcessor... processors) {
try {
Map<UUID, List<DBCallableProcessor>> map = new HashMap<>();
map.put(uuid, Arrays.asList(processors));
queue.add(map);
} catch (IllegalStateException e) {
Log.error(Locale.get(Msg.RUN_WARN_QUEUE_SIZE).parse("Get Queue", 20000));
}
}
@Deprecated
class GetConsumer extends Consumer<Map<UUID, List<DBCallableProcessor>>> {
private Database db;
GetConsumer(BlockingQueue<Map<UUID, List<DBCallableProcessor>>> q, Database db) {
super(q, "GetQueueConsumer");
this.db = db;
}
@Override
protected void consume(Map<UUID, List<DBCallableProcessor>> processors) {
if (!Verify.notNull(processors, db)) {
return;
}
try {
for (Map.Entry<UUID, List<DBCallableProcessor>> entrySet : processors.entrySet()) {
UUID uuid = entrySet.getKey();
List<DBCallableProcessor> processorsList = entrySet.getValue();
if (uuid == null || Verify.isEmpty(processorsList)) {
continue;
}
Log.debug("Database", uuid + ": Get, For:" + processorsList.size());
db.giveUserDataToProcessors(uuid, processorsList);
}
} catch (Exception ex) {
Log.toLog(this.getClass().getName(), ex);
}
}
@Override
protected void clearVariables() {
if (db != null) {
db = null;
}
}
}
@Deprecated
class GetSetup extends Setup<Map<UUID, List<DBCallableProcessor>>> {
GetSetup(BlockingQueue<Map<UUID, List<DBCallableProcessor>>> q, Database db) {
super(new GetConsumer(q, db), new GetConsumer(q, db));
}
}
}

124
Plan/src/main/java/com/djrapitops/plan/queue/DataCacheSaveQueue.java
View File

@ -1,124 +0,0 @@
package main.java.com.djrapitops.plan.queue;
import com.djrapitops.plugin.utilities.Verify;
import main.java.com.djrapitops.plan.Log;
import main.java.com.djrapitops.plan.Plan;
import main.java.com.djrapitops.plan.data.UserData;
import main.java.com.djrapitops.plan.data.cache.DataCacheHandler;
import main.java.com.djrapitops.plan.database.Database;
import main.java.com.djrapitops.plan.locale.Locale;
import main.java.com.djrapitops.plan.locale.Msg;
import java.sql.SQLException;
import java.util.UUID;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
/**
* This Class is starts the Save Queue Thread, that saves data to the Database.
*
* @author Rsl1122
* @since 3.0.0
*/
@Deprecated
public class DataCacheSaveQueue extends Queue<UserData> {
/**
* Class constructor, starts the new Thread for saving.
*
* @param plugin current instance of Plan
* @param handler DataCacheHandler
*/
public DataCacheSaveQueue(Plan plugin, DataCacheHandler handler) {
super(new ArrayBlockingQueue<>(20000));
setup = new SaveSetup(queue, handler, plugin.getDB());
setup.go();
}
/**
* Schedule UserData object to be saved to the database.
*
* @param data UserData object.
*/
public void scheduleForSave(UserData data) {
try {
queue.add(data);
} catch (IllegalStateException e) {
Log.error(Locale.get(Msg.RUN_WARN_QUEUE_SIZE).parse("Save Queue", 20000));
}
}
/**
* Schedule UserData object for a new player to be saved to the database.
*
* @param data UserData object.
*/
public void scheduleNewPlayer(UserData data) {
Log.debug(data.getUuid() + ": Scheduling new Player");
scheduleForSave(data);
}
/**
* Check whether or not the queue contains a UserData object with the uuid.
*
* @param uuid UUID of the player.
* @return true/false
*/
public boolean containsUUID(UUID uuid) {
return uuid != null && queue.stream().anyMatch(d -> d.getUuid().equals(uuid));
}
}
@Deprecated
class SaveConsumer extends Consumer<UserData> {
private Database db;
private DataCacheHandler handler;
SaveConsumer(BlockingQueue<UserData> q, DataCacheHandler handler, Database db) {
super(q, "SaveQueueConsumer");
this.db = db;
this.handler = handler;
run = true;
}
@Override
protected void consume(UserData data) {
if (!Verify.notNull(handler, db, data)) {
return;
}
UUID uuid = data.getUuid();
/*TODO if (handler.getProcessTask().containsUUID(uuid)) { // Wait for process queue.
queue.add(data);
return;
}*/
try {
db.saveUserData(data);
data.stopAccessing();
if (data.shouldClearAfterSave()) {
handler.getClearTask().scheduleForClear(uuid);
}
} catch (SQLException ex) {
Log.toLog(this.getClass().getName(), ex);
}
}
@Override
protected void clearVariables() {
if (db != null) {
db = null;
}
if (handler != null) {
handler = null;
}
}
}
@Deprecated
class SaveSetup extends Setup<UserData> {
SaveSetup(BlockingQueue<UserData> q, DataCacheHandler handler, Database db) {
super(new SaveConsumer(q, handler, db), new SaveConsumer(q, handler, db));
}
}

4
Plan/src/main/java/com/djrapitops/plan/queue/Setup.java
View File

@ -22,13 +22,13 @@ public abstract class Setup<T> {
this.consumers = consumers;
}
void go() {
public void go() {
for (Consumer<T> consumer : consumers) {
Plan.getInstance().getRunnableFactory().createNew(consumer).runTaskAsynchronously();
}
}
void stop() {
public void stop() {
for (Consumer<T> consumer : consumers) {
consumer.stop();
}

23
Plan/src/main/java/com/djrapitops/plan/queue/DataCacheProcessQueue.java → Plan/src/main/java/com/djrapitops/plan/queue/processing/ProcessingQueue.java
View File

@ -1,40 +1,37 @@
package main.java.com.djrapitops.plan.queue;
package main.java.com.djrapitops.plan.queue.processing;
import main.java.com.djrapitops.plan.Log;
import main.java.com.djrapitops.plan.queue.processing.Processor;
import main.java.com.djrapitops.plan.queue.Consumer;
import main.java.com.djrapitops.plan.queue.Queue;
import main.java.com.djrapitops.plan.queue.Setup;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
/**
* This Class is starts the Process Queue Thread, that processes HandlingInfo
* This Class is starts the Process Queue Thread, that processes Processor
* objects.
*
* @author Rsl1122
* @since 3.0.0
*/
public class DataCacheProcessQueue extends Queue<Processor> {
public class ProcessingQueue extends Queue<Processor> {
/**
* Class constructor, starts the new Thread for processing.
*/
public DataCacheProcessQueue() {
public ProcessingQueue() {
super(new ArrayBlockingQueue<>(20000));
setup = new ProcessSetup(queue);
setup.go();
}
/**
* Used to add HandlingInfo object to be processed.
* Used to add Processor object to be processed.
*
* @param processor object that extends HandlingInfo.
* @param processor processing object.
*/
public void addToQueue(Processor processor) {
try {
queue.add(processor);
} catch (IllegalStateException e) {
Log.toLog(this.getClass().getName(), e);
}
queue.offer(processor);
}
}

43
Plan/src/main/java/com/djrapitops/plan/ui/html/RecentPlayersButtonsCreator.java
View File

@ -1,43 +0,0 @@
package main.java.com.djrapitops.plan.ui.html;
import main.java.com.djrapitops.plan.utilities.HtmlUtils;
import java.util.List;
/**
* @author Rsl1122
*/
@Deprecated
public class RecentPlayersButtonsCreator {
/**
* Constructor used to hide the public constructor
*/
private RecentPlayersButtonsCreator() {
throw new IllegalStateException("Utility class");
}
/**
* Creates recent players buttons inside a p-tag.
*
* @param names The name of players sorted by last playtime.
* @param limit How many players will be shown
* @return html p-tag list of recent log-ins.
*/
public static String createRecentLoginsButtons(List<String> names, int limit) {
StringBuilder html = new StringBuilder("<p>");
int i = 0;
for (String name : names) {
if (i >= limit) {
break;
}
html.append(Html.BUTTON.parse(HtmlUtils.getRelativeInspectUrl(name), name)).append(" ");
i++;
}
html.append("</p>");
return html.toString();
}
}

2
Plan/src/main/java/com/djrapitops/plan/ui/html/tables/PlayersTableCreator.java
View File

@ -50,7 +50,7 @@ public class PlayersTableCreator {
String.valueOf(uData.getLoginTimes()),
String.valueOf(uData.getRegistered()), FormatUtils.formatTimeStampYear(uData.getRegistered()),
String.valueOf(uData.getLastPlayed()), FormatUtils.formatTimeStamp(uData.getLastPlayed()),
String.valueOf(uData.getGeolocation())
String.valueOf(uData.getGeolocations()) //TODO get last Geoloc
));
} catch (NullPointerException ignored) {
}

117
Plan/src/main/java/com/djrapitops/plan/ui/text/TextUI.java
View File

@ -1,117 +0,0 @@
package main.java.com.djrapitops.plan.ui.text;
import com.djrapitops.plugin.settings.ColorScheme;
import com.djrapitops.plugin.settings.DefaultMessages;
import main.java.com.djrapitops.plan.Plan;
import main.java.com.djrapitops.plan.data.AnalysisData;
import main.java.com.djrapitops.plan.data.UserData;
import main.java.com.djrapitops.plan.data.analysis.*;
import main.java.com.djrapitops.plan.data.cache.AnalysisCacheHandler;
import main.java.com.djrapitops.plan.data.cache.InspectCacheHandler;
import main.java.com.djrapitops.plan.utilities.FormatUtils;
import main.java.com.djrapitops.plan.utilities.MiscUtils;
import main.java.com.djrapitops.plan.utilities.analysis.AnalysisUtils;
import main.java.com.djrapitops.plan.utilities.analysis.MathUtils;
import org.bukkit.ChatColor;
import java.util.UUID;
/**
* @author Rsl1122
*/
@Deprecated // Too much work to create bungee support for this
public class TextUI {
/**
* Constructor used to hide the public constructor
*/
private TextUI() {
throw new IllegalStateException("Utility class");
}
/**
* @param uuid The UUID for which the inspect messages should be get for
* @return The inspect messages
*/
public static String[] getInspectMessages(UUID uuid) {
InspectCacheHandler inspectCache = Plan.getInstance().getInspectCache();
long now = MiscUtils.getTime();
if (!inspectCache.isCached(uuid)) {
return new String[]{"Error has occurred, please retry."};
}
UserData d = inspectCache.getFromCache(uuid);
ColorScheme cs = Plan.getInstance().getColorScheme();
String main = cs.getMainColor();
String sec = cs.getSecondaryColor();
String ter = cs.getTertiaryColor();
boolean active = AnalysisUtils.isActive(now, d.getLastPlayed(), d.getPlayTime(), d.getLoginTimes());
boolean banned = d.isBanned();
boolean online = d.isOnline();
String ball = sec + " " + DefaultMessages.BALL + main;
String onlineString = online ? ChatColor.GREEN + " Online" : ChatColor.RED + " Offline";
String activeString = active ? " Active" : "Inactive";
String bannedString = banned ? ChatColor.DARK_RED + " Banned" : ter + activeString;
return new String[]{
sec + " " + DefaultMessages.BALL + bannedString + onlineString,
ball + " Registered: " + sec + FormatUtils.formatTimeStampYear(d.getRegistered()),
ball + " Last seen: " + sec + FormatUtils.formatTimeStamp(d.getLastPlayed()),
ball + " Playtime: " + sec + FormatUtils.formatTimeAmount(d.getPlayTime()),
ball + " Login times: " + sec + d.getLoginTimes(),
ball + " Average session length: " + sec + FormatUtils.formatTimeAmount(MathUtils.averageLong(AnalysisUtils.transformSessionDataToLengths(d.getSessions()))),
ball + " Kills: " + sec + d.getPlayerKills().size() + main + " Mobs: " + sec + d.getMobKills() + main + " Deaths: " + sec + d.getDeaths(),
ball + " Geolocation: " + sec + d.getGeolocation()
};
}
/**
* Gets the analysis messages
*
* @return The analysis messages
*/
public static String[] getAnalysisMessages() {
AnalysisCacheHandler analysisCache = Plan.getInstance().getAnalysisCache();
if (!analysisCache.isCached()) {
return new String[]{"Error has occurred, please retry."};
}
AnalysisData d = analysisCache.getData();
ColorScheme cs = Plan.getInstance().getColorScheme();
String main = cs.getMainColor();
String sec = cs.getSecondaryColor();
String ball = sec + " " + DefaultMessages.BALL + main;
final ActivityPart activity = d.getActivityPart();
final JoinInfoPart join = d.getJoinInfoPart();
final KillPart kills = d.getKillPart();
final PlaytimePart playtime = d.getPlaytimePart();
final PlayerCountPart count = d.getPlayerCountPart();
final TPSPart tps = d.getTpsPart();
return new String[]{
ball + " Total Players: " + sec + count.getPlayerCount(),
ball + " Active: " + sec + activity.getActive().size()
+ main + " Inactive: " + sec + activity.getInactive().size()
+ main + " Single Join: " + sec + activity.getJoinedOnce().size()
+ main + " Banned: " + sec + activity.getBans().size(),
ball + " New Players 24h: " + sec + join.get("npday") + main + " 7d: " + sec + d.get("npweek") + main + " 30d: " + sec + d.get("npmonth"),
"",
ball + " Total Playtime: " + sec + playtime.get("totalplaytime") + main + " Player Avg: " + sec + playtime.get("avgplaytime"),
ball + " Average Session Length: " + sec + activity.get("sessionaverage"),
ball + " Total Logintimes: " + sec + join.getLoginTimes(),
ball + " Kills: " + sec + kills.getAllPlayerKills().size() + main + " Mobs: " + sec + kills.getMobKills() + main + " Deaths: " + sec + kills.getDeaths(),
"",
ball + " Average TPS 24h: " + sec + tps.get("averagetpsday")
};
}
}

5
Plan/src/main/java/com/djrapitops/plan/utilities/ManageUtils.java
View File

@ -3,7 +3,6 @@ package main.java.com.djrapitops.plan.utilities;
import com.djrapitops.plugin.utilities.Verify;
import main.java.com.djrapitops.plan.Log;
import main.java.com.djrapitops.plan.Plan;
import main.java.com.djrapitops.plan.data.UserData;
import main.java.com.djrapitops.plan.database.Database;
import main.java.com.djrapitops.plan.database.databases.SQLiteDB;
@ -69,8 +68,8 @@ public class ManageUtils {
public static boolean clearAndCopy(Database clearAndCopyToDB, Database copyFromDB) {
try {
clearAndCopyToDB.removeAllData();
List<UserData> allUserData = copyFromDB.getUserDataForUUIDS(copyFromDB.getSavedUUIDs());
clearAndCopyToDB.saveMultipleUserData(allUserData);
//TODO List<UserData> allUserData = copyFromDB.getUserDataForUUIDS(copyFromDB.getSavedUUIDs());
// clearAndCopyToDB.saveMultipleUserData(allUserData);
clearAndCopyToDB.getCommandUseTable().saveCommandUse(copyFromDB.getCommandUseTable().getCommandUse());
clearAndCopyToDB.getTpsTable().saveTPSData(copyFromDB.getTpsTable().getTPSData());
} catch (SQLException | NullPointerException e) {

13
Plan/src/main/java/com/djrapitops/plan/utilities/NewPlayerCreator.java
View File

@ -45,17 +45,8 @@ public class NewPlayerCreator {
* @return a new UserData object
*/
public static UserData createNewPlayer(IOfflinePlayer player, Gamemode gm) {
long registered = player.getFirstPlayed();
UserData data = new UserData(player.getUniqueId(), registered, player.isOp(), gm.name(), player.getName(), player.isOnline());
data.setLastPlayed(MiscUtils.getTime());
data.setPlayTime(0L);
data.setTimesKicked(0);
data.setLoginTimes(0);
data.setDeaths(0);
data.setMobKills(0);
data.setBanned(false);
data.setGeolocation("Not Known");
return data;
// TODO Rewrite
return null;
}
}

11
Plan/src/main/java/com/djrapitops/plan/utilities/PlaceholderUtils.java
View File

@ -5,7 +5,6 @@ import main.java.com.djrapitops.plan.Settings;
import main.java.com.djrapitops.plan.data.AnalysisData;
import main.java.com.djrapitops.plan.data.SessionData;
import main.java.com.djrapitops.plan.data.UserData;
import main.java.com.djrapitops.plan.data.time.WorldTimes;
import main.java.com.djrapitops.plan.ui.html.graphs.PunchCardGraphCreator;
import java.io.Serializable;
@ -68,16 +67,16 @@ public class PlaceholderUtils {
replaceMap.put("lastSeen", FormatUtils.formatTimeStampYear(data.getLastPlayed()));
replaceMap.put("sessionCount", data.getSessions().size());
replaceMap.put("playtimeTotal", FormatUtils.formatTimeAmount(data.getPlayTime()));
//TODO replaceMap.put("playtimeTotal", FormatUtils.formatTimeAmount(data.getPlayTime()));
replaceMap.put("kickCount", data.getTimesKicked());
replaceMap.put("playerKillCount", data.getPlayerKills().size());
replaceMap.put("mobKillCount", data.getMobKills());
replaceMap.put("deathCount", data.getDeaths());
// replaceMap.put("playerKillCount", data.getPlayerKills().size()); //TODO
// replaceMap.put("mobKillCount", data.getMobKills());
// replaceMap.put("deathCount", data.getDeaths());
Set<SessionData> sessions = new HashSet<>(data.getSessions());
replaceMap.put("punchCardSeries", PunchCardGraphCreator.createDataSeries(sessions));
WorldTimes worldTimes = data.getWorldTimes();
//TODO WorldTimes worldTimes = data.getWorldTimes();
// TODO replaceMap.put("worldSeries", WorldPieCreator.createSeriesData(worldTimes.getTimes()));
// replaceMap.put("worldTotal", FormatUtils.formatTimeAmount(worldTimes.getTotal()));

38
Plan/src/main/java/com/djrapitops/plan/utilities/analysis/Analysis.java
View File

@ -4,13 +4,16 @@ import com.djrapitops.plugin.task.AbsRunnable;
import com.djrapitops.plugin.utilities.Verify;
import main.java.com.djrapitops.plan.Log;
import main.java.com.djrapitops.plan.Plan;
import main.java.com.djrapitops.plan.data.*;
import main.java.com.djrapitops.plan.data.AnalysisData;
import main.java.com.djrapitops.plan.data.SessionData;
import main.java.com.djrapitops.plan.data.TPS;
import main.java.com.djrapitops.plan.data.UserData;
import main.java.com.djrapitops.plan.data.additional.AnalysisType;
import main.java.com.djrapitops.plan.data.additional.HookHandler;
import main.java.com.djrapitops.plan.data.additional.PluginData;
import main.java.com.djrapitops.plan.data.analysis.*;
import main.java.com.djrapitops.plan.data.cache.AnalysisCacheHandler;
import main.java.com.djrapitops.plan.data.cache.DataCacheHandler;
import main.java.com.djrapitops.plan.data.cache.DataCache;
import main.java.com.djrapitops.plan.data.cache.InspectCacheHandler;
import main.java.com.djrapitops.plan.data.cache.PageCacheHandler;
import main.java.com.djrapitops.plan.database.Database;
@ -126,7 +129,7 @@ public class Analysis {
rawData.sort(new UserDataLastPlayedComparator());
List<UUID> uuids = rawData.stream().map(UserData::getUuid).collect(Collectors.toList());
Benchmark.start("Create Empty dataset");
DataCacheHandler handler = plugin.getHandler();
DataCache handler = plugin.getHandler();
Map<String, Integer> commandUse = handler.getCommandUse();
AnalysisData analysisData = new AnalysisData(commandUse, tpsData);
@ -266,28 +269,13 @@ public class Analysis {
List<PluginData> banSources = plugin.getHookHandler().getAdditionalDataSources()
.stream().filter(PluginData::isBanData).collect(Collectors.toList());
rawData.forEach(uData -> {
uData.access();
Map<String, Long> gmTimes = uData.getGmTimes().getTimes();
String[] gms = new String[]{"SURVIVAL", "CREATIVE", "ADVENTURE", "SPECTATOR"};
if (gmTimes != null) {
for (String gm : gms) {
Long time = gmTimes.get(gm);
if (time != null) {
gmPart.addTo(gm, time);
}
}
}
// TODO Map<String, Long> worldTimes = uData.getWorldTimes().getTimes();
// for (Map.Entry<String, Long> world : worldTimes.entrySet()) {
// worldPart.addToWorld(world.getKey(), world.getValue());
// }
final long playTime = uData.getPlayTime();
playtime.addToPlaytime(playTime);
// TODO playtime.addToPlaytime(playTime);
joinInfo.addToLoginTimes(uData.getLoginTimes());
joinInfo.addRegistered(uData.getRegistered());
geolocPart.addGeolocation(uData.getGeolocation());
//TODO geolocPart.addGeolocation(uData.getGeolocation());
final UUID uuid = uData.getUuid();
if (uData.isOp()) {
@ -310,19 +298,15 @@ public class Analysis {
activity.addBan(uuid);
} else if (uData.getLoginTimes() == 1) {
activity.addJoinedOnce(uuid);
} else if (AnalysisUtils.isActive(now, uData.getLastPlayed(), playTime, uData.getLoginTimes())) {
activity.addActive(uuid);
// TODO } else if (AnalysisUtils.isActive(now, uData.getLastPlayed(), playTime, uData.getLoginTimes())) {
// activity.addActive(uuid);
} else {
activity.addInActive(uuid);
}
List<KillData> playerKills = uData.getPlayerKills();
killPart.addKills(uuid, playerKills);
killPart.addDeaths(uData.getDeaths());
killPart.addMobKills(uData.getMobKills());
//TODO List<KillData> playerKills = uData.getPlayerKills();
List<SessionData> sessions = uData.getSessions();
joinInfo.addSessions(uuid, sessions);
uData.stopAccessing();
});
Benchmark.stop("Analysis", "Fill Dataset");
}

302
Plan/test/test/java/main/java/com/djrapitops/plan/data/UserDataTest.java
View File

@ -1,27 +1,12 @@
package test.java.main.java.com.djrapitops.plan.data;
import com.djrapitops.plugin.utilities.player.IOfflinePlayer;
import main.java.com.djrapitops.plan.Plan;
import main.java.com.djrapitops.plan.data.SessionData;
import main.java.com.djrapitops.plan.data.UserData;
import org.bukkit.plugin.java.JavaPlugin;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import test.java.utils.TestInit;
import test.java.utils.MockUtils;
import java.io.IOException;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* @author Rsl1122
@ -29,6 +14,7 @@ import static org.junit.Assert.assertTrue;
@RunWith(PowerMockRunner.class)
@PrepareForTest(JavaPlugin.class)
public class UserDataTest {
// TODO Rewrite
private UserData test;
private Plan plan;
@ -45,291 +31,5 @@ public class UserDataTest {
@Before
public void setUp() throws Exception {
// TestInit t = TestInit.init();
test = new UserData(UUID.fromString("7f8149a0-b5a5-4fcd-80b5-6cff083a99f1"), 0, true, "CREATIVE", "Testname", true);
}
/**
* @throws UnknownHostException
*/
@Test
public void testAddIpAddress() throws UnknownHostException {
InetAddress ip = InetAddress.getByName("247.183.163.155");
InetAddress ip2 = InetAddress.getByName("95.19.221.226");
test.addIpAddress(ip);
test.addIpAddress(ip2);
test.addIpAddress(ip2);
test.addIpAddress(null);
assertTrue("Didn't add 1", test.getIps().contains(ip));
assertTrue("Didn't add 2", test.getIps().contains(ip2));
assertTrue("Added null", !test.getIps().contains(null));
assertTrue("Added multiples", test.getIps().size() == 2);
}
/**
* @throws UnknownHostException
*/
@Test
public void testAddIpAddresses() throws UnknownHostException {
List<InetAddress> ips = new ArrayList<>();
InetAddress ip = InetAddress.getByName("247.183.163.155");
InetAddress ip2 = InetAddress.getByName("95.19.221.226");
ips.add(ip);
ips.add(ip2);
ips.add(ip2);
ips.add(null);
test.addIpAddresses(ips);
assertTrue("Didn't add 1", test.getIps().contains(ip));
assertTrue("Didn't add 2", test.getIps().contains(ip2));
assertTrue("Added null", !test.getIps().contains(null));
assertTrue("Added multiples", test.getIps().size() == 2);
}
/**
*
*/
@Test
public void testAddIpAddressesEmpty() {
List<InetAddress> ips = new ArrayList<>();
test.addIpAddresses(ips);
assertTrue("Added something", test.getIps().isEmpty());
}
/**
*
*/
@Test
public void testAddNickname() {
String one = "Test1";
String two = "Test2";
boolean n1 = test.addNickname(two);
boolean n2 = test.addNickname(two);
boolean n = test.addNickname(one);
test.addNickname(null);
assertTrue("Didn't add 1", test.getNicknames().contains(one));
assertTrue("Didn't add 2", test.getNicknames().contains(two));
assertTrue("1 is supposed to be new", n);
assertTrue("2 is supposed to be new", n1);
assertTrue("2 is not supposed to be new", !n2);
assertTrue("Added null", !test.getNicknames().contains(null));
assertTrue("Added multiples", test.getNicknames().size() == 2);
assertTrue("Last nickname was not one", test.getLastNick().equals(one));
}
/**
*
*/
@Test
public void testAddNicknames() {
String one = "Test1";
String two = "Test2";
List<String> o = new ArrayList<>();
o.add(one);
o.add(two);
o.add(two);
o.add(null);
test.addNicknames(o);
assertTrue("Didn't add 1", test.getNicknames().contains(one));
assertTrue("Didn't add 2", test.getNicknames().contains(two));
assertTrue("Added null", !test.getNicknames().contains(null));
assertTrue("Added multiples", test.getNicknames().size() == 2);
}
/**
*
*/
@Test
public void testAddNicknamesEmpty() {
List<String> o = new ArrayList<>();
test.addNicknames(o);
assertTrue("Added something", test.getNicknames().isEmpty());
}
/**
*
*/
@Test
public void testAddSession() {
SessionData correct = new SessionData(0, 1);
test.addSession(correct);
assertTrue("Didn't add correct one", test.getSessions().contains(correct));
}
/**
*
*/
@Test
public void testAddSessionIncorrect() {
SessionData incorrect = new SessionData(0);
test.addSession(incorrect);
assertTrue("Added incorrect one", !test.getSessions().contains(incorrect));
}
/**
*
*/
@Test
public void testAddSessionNull() {
test.addSession(null);
assertTrue("Added null", !test.getSessions().contains(null));
}
/**
*
*/
@Test
public void testAddSessions() {
SessionData correct = new SessionData(0, 1);
SessionData incorrect = new SessionData(0);
List<SessionData> o = new ArrayList<>();
o.add(correct);
o.add(incorrect);
o.add(null);
test.addSessions(o);
assertTrue("Didn't add correct one", test.getSessions().contains(correct));
assertTrue("Added incorrect one", !test.getSessions().contains(incorrect));
assertTrue("Added null", !test.getSessions().contains(incorrect));
}
/**
*
*/
@Test
public void testAddSessionsEmpty() {
List<SessionData> o = new ArrayList<>();
test.addSessions(o);
assertTrue("Added something", test.getSessions().isEmpty());
}
/**
*
*/
@Test
public void testUpdateBanned() {
test.updateBanned(true);
assertTrue("Not true", test.isBanned());
test.updateBanned(false);
assertTrue("True", !test.isBanned());
}
/**
*
*/
@Test
public void testIsAccessed() {
test.access();
assertTrue("Not accessed, even though accessing", test.isAccessed());
test.access();
test.stopAccessing();
assertTrue("Not accessed, even though accessing", test.isAccessed());
test.stopAccessing();
assertTrue("Accessed, even though not accessing", !test.isAccessed());
}
/**
*
*/
@Test
public void testAccess() {
test.access();
assertTrue("Not accessed, even though accessing", test.isAccessed());
}
/**
*
*/
@Test
public void testStopAccessing() {
test.access();
test.stopAccessing();
assertTrue("Accessed, even though not accessing", !test.isAccessed());
}
/**
*
*/
@Test
public void testEquals() {
assertTrue("Not Equals!", test.equals(new UserData(UUID.fromString("7f8149a0-b5a5-4fcd-80b5-6cff083a99f1"), 0, true, "CREATIVE", "Testname", true)));
}
/**
*
*/
@Test
public void testEqualsNot() {
UserData notEqual = new UserData(UUID.fromString("7f8149a0-b5a5-4fcd-80b5-6cff083a99f1"), 0, true, "CREATIVE", "WRONG", true);
assertTrue("Equals!", !notEqual.equals(test));
}
/**
*
*/
@Test
public void testEqualsNot2() {
Object o = "NOT";
assertTrue("Equals!", !test.equals(o));
}
/**
*
*/
@Test
public void testCopyConstructor() {
UserData copy = new UserData(test);
assertTrue("Not copied properly", test.equals(copy));
}
/**
*
*/
@Test
public void testPlayerConstructor() {
test = new UserData(MockUtils.mockIPlayer());
UserData expected = new UserData(UUID.fromString("45b0dfdb-f71d-4cf3-8c21-27c9d4c651db"), 1234567L, true, "SURVIVAL", "TestName", true);
expected.updateBanned(true);
assertTrue("Not equal!", test.equals(expected));
}
/**
* @throws IOException
*/
@Test
public void testPlayerConstructorBrokenBanned() throws Exception {
TestInit.init();
test = new UserData(MockUtils.mockBrokenPlayer());
UserData expected = new UserData(UUID.fromString("45b0dfdb-f71d-4cf3-8c21-27c9d4c651db"), 1234567L, true, "SURVIVAL", "TestName", true);
expected.updateBanned(false);
assertTrue("Not equal!", test.equals(expected));
}
/**
*
*/
@Test
public void testOfflinePlayerConstructor() {
test = new UserData((IOfflinePlayer) MockUtils.mockIPlayer());
UserData expected = new UserData(UUID.fromString("45b0dfdb-f71d-4cf3-8c21-27c9d4c651db"), 1234567L, true, "SURVIVAL", "TestName", true);
expected.updateBanned(true);
assertTrue("Not equal!", test.equals(expected));
}
/**
* @throws IOException
*/
@Test
public void testOfflinePlayerConstructorBrokenBanned() throws Exception {
TestInit.init();
test = new UserData((IOfflinePlayer) MockUtils.mockBrokenPlayer());
UserData expected = new UserData(UUID.fromString("45b0dfdb-f71d-4cf3-8c21-27c9d4c651db"), 1234567L, true, "SURVIVAL", "TestName", true);
expected.updateBanned(false);
assertTrue("Not equal!", test.equals(expected));
}
/**
*
*/
@Test
public void testGetUUID() {
assertEquals(test.getUuid(), UUID.fromString("7f8149a0-b5a5-4fcd-80b5-6cff083a99f1"));
}
}

8
Plan/test/test/java/main/java/com/djrapitops/plan/data/cache/DataCacheHandlerTest.java → Plan/test/test/java/main/java/com/djrapitops/plan/data/cache/DataCacheTest.java vendored
View File

@ -5,7 +5,7 @@
*/
package test.java.main.java.com.djrapitops.plan.data.cache;
import main.java.com.djrapitops.plan.data.cache.DataCacheHandler;
import main.java.com.djrapitops.plan.data.cache.DataCache;
import main.java.com.djrapitops.plan.database.Database;
import org.bukkit.plugin.java.JavaPlugin;
import org.junit.After;
@ -18,10 +18,10 @@ import org.powermock.modules.junit4.PowerMockRunner;
@RunWith(PowerMockRunner.class)
@PrepareForTest(JavaPlugin.class)
public class DataCacheHandlerTest {
public class DataCacheTest {
private Database db;
private DataCacheHandler handler;
private DataCache handler;
private int callsToSaveCommandUse;
private int callsToSaveUserData;
@ -30,7 +30,7 @@ public class DataCacheHandlerTest {
/**
*
*/
public DataCacheHandlerTest() {
public DataCacheTest() {
}
/**

12
Plan/test/test/java/main/java/com/djrapitops/plan/data/cache/SessionCacheTest.java vendored
View File

@ -6,7 +6,6 @@
package test.java.main.java.com.djrapitops.plan.data.cache;
import main.java.com.djrapitops.plan.data.SessionData;
import main.java.com.djrapitops.plan.data.UserData;
import main.java.com.djrapitops.plan.data.cache.SessionCache;
import org.bukkit.plugin.java.JavaPlugin;
import org.junit.Before;
@ -59,15 +58,4 @@ public class SessionCacheTest {
assertTrue("Session length not positive", testSession.getLength() > 0L);
assertTrue("Session not valid", testSession.isValid());
}
@Test
public void testAddSession() {
UUID uuid = MockUtils.getPlayerUUID();
test.getActiveSessions().put(uuid, new SessionData(0));
test.endSession(uuid);
UserData data = MockUtils.mockUser();
test.addSession(data);
assertTrue("Didn't add session to data", data.getSessions().size() == 1);
}
}

86
Plan/test/test/java/main/java/com/djrapitops/plan/data/cache/queue/DataCacheQueueTest.java → Plan/test/test/java/main/java/com/djrapitops/plan/data/cache/queue/QueueTest.java vendored
View File

@ -8,9 +8,7 @@ package test.java.main.java.com.djrapitops.plan.data.cache.queue;
import main.java.com.djrapitops.plan.Plan;
import main.java.com.djrapitops.plan.data.UserData;
import main.java.com.djrapitops.plan.data.cache.DBCallableProcessor;
import main.java.com.djrapitops.plan.data.cache.DataCacheHandler;
import main.java.com.djrapitops.plan.data.handling.info.HandlingInfo;
import main.java.com.djrapitops.plan.data.handling.info.InfoType;
import main.java.com.djrapitops.plan.data.cache.DataCache;
import main.java.com.djrapitops.plan.database.Database;
import main.java.com.djrapitops.plan.database.databases.SQLiteDB;
import main.java.com.djrapitops.plan.utilities.MiscUtils;
@ -30,12 +28,14 @@ import java.util.Collection;
import java.util.List;
import java.util.UUID;
import static org.junit.Assert.*;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import static org.powermock.api.mockito.PowerMockito.when;
// TODO Rewrite
@RunWith(PowerMockRunner.class)
@PrepareForTest({JavaPlugin.class})
public class DataCacheQueueTest {
public class QueueTest {
private final UUID uuid1 = MockUtils.getPlayerUUID();
private final UserData data1 = MockUtils.mockUserWithMoreData();
@ -44,10 +44,10 @@ public class DataCacheQueueTest {
private int callsToSaveUserData;
private int callsToGetUserData;
private DataCacheHandler handler;
private DataCache handler;
private Database db;
public DataCacheQueueTest() {
public QueueTest() {
}
@Before
@ -89,7 +89,7 @@ public class DataCacheQueueTest {
};
db.init();
when(plan.getDB()).thenReturn(db);
handler = new DataCacheHandler(plan) {
handler = new DataCache(plan) {
@Override
public void startAsyncPeriodicSaveTask() {
}
@ -102,65 +102,21 @@ public class DataCacheQueueTest {
db.close();
}
@Test
public void testGetQueue_cache() {
List<Integer> calls = new ArrayList<>();
List<Integer> errors = new ArrayList<>();
handler.getUserDataForProcessing(data -> {
if (data.equals(data1)) {
calls.add(1);
} else {
errors.add(1);
}
}, uuid1);
while (calls.size() < 1) {
if (errors.size() > 0) {
fail();
}
}
assertEquals(1, calls.size());
assertEquals(0, errors.size());
assertEquals(1, callsToGetUserData);
assertTrue(handler.getDataCache().containsKey(uuid1));
}
@Test
public void testGetQueue_dontCache() {
List<Integer> getCalls = new ArrayList<>();
List<Integer> errors = new ArrayList<>();
handler.getUserDataForProcessing(data -> {
if (data.equals(data1)) {
getCalls.add(1);
} else {
errors.add(1);
}
}, uuid1, false);
while (getCalls.size() < 1) {
if (errors.size() > 0) {
fail();
}
}
assertEquals(1, getCalls.size());
assertEquals(0, errors.size());
assertEquals(1, callsToGetUserData);
assertTrue(!handler.getDataCache().containsKey(uuid1));
}
@Test
public void testProcessQueue() {
List<Integer> processCalls = new ArrayList<>();
List<Integer> errors = new ArrayList<>();
handler.addToPool(new HandlingInfo(uuid1, InfoType.OTHER, 0) {
@Override
public void process(UserData uData) {
if (uData.equals(data1)) {
uData.setName("TestSuccessful");
processCalls.add(1);
} else {
errors.add(1);
}
}
});
// handler.addToPool(new HandlingInfo(uuid1, InfoType.OTHER, 0) {
// @Override
// public void process(UserData uData) {
// if (uData.equals(data1)) {
// uData.setName("TestSuccessful");
// processCalls.add(1);
// } else {
// errors.add(1);
// }
// }
// });
while (processCalls.size() < 1) {
if (errors.size() > 0) {
fail();
@ -169,9 +125,5 @@ public class DataCacheQueueTest {
assertEquals(1, processCalls.size());
assertEquals(0, errors.size());
assertEquals(1, callsToGetUserData);
assertTrue(handler.getDataCache().containsKey(uuid1));
assertEquals("TestSuccessful", handler.getDataCache().get(uuid1).getName());
}
// TODO Save & Clear Queue tests
}

52
Plan/test/test/java/main/java/com/djrapitops/plan/data/handling/ChatHandlingTest.java
View File

@ -1,52 +0,0 @@
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package test.java.main.java.com.djrapitops.plan.data.handling;
import main.java.com.djrapitops.plan.data.UserData;
import main.java.com.djrapitops.plan.data.handling.ChatHandling;
import org.bukkit.plugin.java.JavaPlugin;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import test.java.utils.MockUtils;
import test.java.utils.TestInit;
import static org.junit.Assert.assertTrue;
/**
* @author Rsl1122
*/
@RunWith(PowerMockRunner.class)
@PrepareForTest(JavaPlugin.class)
public class ChatHandlingTest {
/**
*
*/
public ChatHandlingTest() {
}
/**
*
*/
@Before
public void setUp() throws Exception {
TestInit.init();
}
/**
*
*/
@Test
public void testProcessChatInfoAddedNickname() {
UserData data = MockUtils.mockUser2();
String expected = "TestNicknameChatHandling";
ChatHandling.processChatInfo(data, expected);
assertTrue("Didn't add nickname", data.getNicknames().contains(expected));
}
}

145
Plan/test/test/java/main/java/com/djrapitops/plan/data/handling/KillHandlingTest.java
View File

@ -1,145 +0,0 @@
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package test.java.main.java.com.djrapitops.plan.data.handling;
import com.djrapitops.plugin.utilities.player.IPlayer;
import main.java.com.djrapitops.plan.Plan;
import main.java.com.djrapitops.plan.data.KillData;
import main.java.com.djrapitops.plan.data.UserData;
import main.java.com.djrapitops.plan.data.handling.KillHandling;
import main.java.com.djrapitops.plan.database.Database;
import main.java.com.djrapitops.plan.database.databases.SQLiteDB;
import main.java.com.djrapitops.plan.database.tables.UsersTable;
import main.java.com.djrapitops.plan.utilities.MiscUtils;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.plugin.java.JavaPlugin;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import test.java.utils.MockUtils;
import test.java.utils.TestInit;
import java.io.IOException;
import java.sql.SQLException;
import java.util.UUID;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.powermock.api.mockito.PowerMockito.when;
/**
* @author Rsl1122
*/
@RunWith(PowerMockRunner.class)
@PrepareForTest(JavaPlugin.class)
public class KillHandlingTest {
private Database db;
/**
*
*/
public KillHandlingTest() {
}
/**
*
*/
@Before
public void setUp() throws Exception {
TestInit t = TestInit.init();
Plan plan = t.getPlanMock();
db = new SQLiteDB(plan, "debug" + MiscUtils.getTime()) {
@Override
public void startConnectionPingTask() {
}
@Override
public void convertBukkitDataToDB() {
}
@Override
public UsersTable getUsersTable() {
return new UsersTable(null, false) {
@Override
public int getUserId(UUID uuid) {
if (uuid.equals(MockUtils.getPlayerUUID())) {
return -1;
}
return 1;
}
};
}
};
when(plan.getDB()).thenReturn(db);
}
/**
* @throws SQLException
*/
@After
public void tearDown() throws SQLException {
db.close();
}
/**
* @throws SQLException
*/
@Test
public void testProcessKillInfoPlayer() throws SQLException {
UserData data = MockUtils.mockUser();
IPlayer dead = MockUtils.mockIPlayer2();
KillHandling.processKillInfo(data, 10L, (Player) dead.getWrappedPlayerClass(), "TestWeapon");
KillData expected = new KillData(dead.getUuid(), 1, "TestWeapon", 10L);
assertTrue("Didn't add the kill", data.getPlayerKills().size() == 1);
KillData result = data.getPlayerKills().get(0);
assertEquals(expected.getDate(), result.getDate());
assertEquals(expected.getVictim(), result.getVictim());
assertEquals(expected.getVictimUserID(), result.getVictimUserID());
assertEquals(expected.getWeapon(), result.getWeapon());
}
/**
* @throws SQLException
* @throws IOException
*/
@Test
public void testProcessKillInfoException() throws SQLException, IOException {
UserData data = MockUtils.mockUser2();
Player dead = (Player) MockUtils.mockIPlayer().getWrappedPlayerClass();
KillHandling.processKillInfo(data, 10L, dead, "TestWeapon");
assertTrue("Added the kill", data.getPlayerKills().isEmpty());
}
/**
* @throws SQLException
*/
@Test
public void testProcessKillInfoMob() throws SQLException {
UserData data = MockUtils.mockUser();
int mobKills = data.getMobKills();
int exp = mobKills + 1;
KillHandling.processKillInfo(data, 10L, null, "TestWeapon");
int result = data.getMobKills();
assertEquals(exp, result);
}
@Test
public void testNormalizeMaterialName() {
Material material = Material.GOLD_SWORD;
String name = material.name();
String normalizedName = KillHandling.normalizeMaterialName(material);
assertEquals(name, "GOLD_SWORD");
assertEquals(normalizedName, "Gold Sword");
}
}

80
Plan/test/test/java/main/java/com/djrapitops/plan/data/handling/LoginHandlingTest.java
View File

@ -1,80 +0,0 @@
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package test.java.main.java.com.djrapitops.plan.data.handling;
import main.java.com.djrapitops.plan.data.UserData;
import main.java.com.djrapitops.plan.data.handling.LoginHandling;
import org.bukkit.plugin.java.JavaPlugin;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import test.java.utils.MockUtils;
import test.java.utils.TestInit;
import java.net.InetAddress;
import java.net.UnknownHostException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* @author Rsl1122
*/
@RunWith(PowerMockRunner.class)
@PrepareForTest(JavaPlugin.class)
public class LoginHandlingTest {
/**
*
*/
public LoginHandlingTest() {
}
/**
*
*/
@Before
public void setUp() throws Exception {
TestInit.init();
}
/**
* @throws UnknownHostException
*/
@Test
public void testProcessLoginInfo() throws UnknownHostException {
UserData data = MockUtils.mockUser();
data.updateBanned(false);
InetAddress ip = InetAddress.getByName("137.19.188.146");
long time = 10L;
int loginTimes = data.getLoginTimes();
String nick = "TestProcessLoginInfo";
LoginHandling.processLoginInfo(data, time, ip, true, nick, 1);
assertTrue("Not Banned", data.isBanned());
assertTrue("LastPlayed wrong", data.getLastPlayed() == time);
assertTrue("Ip not added", data.getIps().contains(ip));
assertTrue("Logintimes not +1", data.getLoginTimes() == loginTimes + 1);
assertTrue("Nick not added", data.getNicknames().contains(nick));
assertTrue("Nick not last nick", data.getLastNick().equals(nick));
String result = data.getGeolocation();
assertEquals("United States", result);
}
/**
* @throws UnknownHostException
*/
@Test
public void testUpdateGeolocation() throws UnknownHostException {
UserData data = MockUtils.mockUser();
InetAddress ip = InetAddress.getByName("137.19.188.146");
LoginHandling.updateGeolocation(ip, data);
String result = data.getGeolocation();
assertEquals("United States", result);
}
}

49
Plan/test/test/java/main/java/com/djrapitops/plan/data/handling/LogoutHandlingTest.java
View File

@ -1,49 +0,0 @@
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package test.java.main.java.com.djrapitops.plan.data.handling;
import main.java.com.djrapitops.plan.data.UserData;
import main.java.com.djrapitops.plan.data.handling.LogoutHandling;
import org.junit.Before;
import org.junit.Test;
import test.java.utils.MockUtils;
import static org.junit.Assert.assertTrue;
/**
* @author Rsl1122
*/
public class LogoutHandlingTest {
/**
*
*/
public LogoutHandlingTest() {
}
/**
*
*/
@Before
public void setUp() throws Exception {
}
/**
*
*/
@Test
public void testProcessLogoutInfo() {
UserData data = MockUtils.mockUser();
data.setLastPlayed(10L);
data.updateBanned(false);
long time = 20L;
LogoutHandling.processLogoutInfo(data, time, true);
assertTrue("Last Played wrong", data.getLastPlayed() == 20L);
assertTrue("Playtime wrong", data.getPlayTime() == 10L);
assertTrue("Banned wrong", data.isBanned());
}
}

23
Plan/test/test/java/main/java/com/djrapitops/plan/data/handling/info/LogoutInfoTest.java
View File

@ -5,15 +5,8 @@
*/
package test.java.main.java.com.djrapitops.plan.data.handling.info;
import main.java.com.djrapitops.plan.data.SessionData;
import main.java.com.djrapitops.plan.data.UserData;
import main.java.com.djrapitops.plan.data.handling.info.LogoutInfo;
import org.junit.Before;
import org.junit.Test;
import test.java.utils.MockUtils;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* @author Rsl1122
@ -36,20 +29,8 @@ public class LogoutInfoTest {
/**
*
*/
@Test
@Test //TODO Rewrite
public void testProcess() {
UserData data = MockUtils.mockUser();
data.setLastPlayed(10L);
data.updateBanned(false);
long time = 20L;
data.getGmTimes().setState("SURVIVAL");
LogoutInfo i = new LogoutInfo(data.getUuid(), time, true, "CREATIVE", new SessionData(0, 1), "World");
i.process(data);
assertTrue("Last Played wrong", data.getLastPlayed() == 20L);
assertTrue("Playtime wrong", data.getPlayTime() == 10L);
assertTrue("Banned wrong", data.isBanned());
assertEquals("CREATIVE", data.getGmTimes().getState());
// TODO assertEquals("World", data.getWorldTimes().getState());
assertEquals(1, data.getSessions().size());
}
}

88
Plan/test/test/java/main/java/com/djrapitops/plan/database/DatabaseTest.java
View File

@ -6,13 +6,8 @@
package test.java.main.java.com.djrapitops.plan.database;
import main.java.com.djrapitops.plan.Plan;
import main.java.com.djrapitops.plan.data.KillData;
import main.java.com.djrapitops.plan.data.SessionData;
import main.java.com.djrapitops.plan.data.TPS;
import main.java.com.djrapitops.plan.data.UserData;
import main.java.com.djrapitops.plan.data.cache.DBCallableProcessor;
import main.java.com.djrapitops.plan.data.time.GMTimes;
import main.java.com.djrapitops.plan.data.time.WorldTimes;
import main.java.com.djrapitops.plan.database.Database;
import main.java.com.djrapitops.plan.database.databases.MySQLDB;
import main.java.com.djrapitops.plan.database.databases.SQLiteDB;
@ -36,8 +31,6 @@ import java.io.File;
import java.io.IOException;
import java.lang.management.ManagementFactory;
import java.lang.management.OperatingSystemMXBean;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.sql.SQLException;
import java.util.*;
@ -212,87 +205,6 @@ public class DatabaseTest {
assertEquals(c, commandUse);
}
/**
* @throws SQLException
*/
@Test
public void testSaveUserData() throws SQLException {
db.init();
UserData data = MockUtils.mockUser();
GMTimes gmTimes = data.getGmTimes();
gmTimes.setAllGMTimes(5L, 10L, 15L, 20L);
gmTimes.setState("SURVIVAL");
gmTimes.setLastStateChange(10L);
WorldTimes worldTimes = data.getWorldTimes();
// TODO worldTimes.setTime("World", 20L);
// worldTimes.setState("World");
// worldTimes.setLastStateChange(10L);
db.saveUserData(data);
data.addNickname("TestUpdateForSave");
db.saveUserData(data);
DBCallableProcessor process = d -> {
System.out.println("\nOriginal: " + data);
System.out.println("Database: " + d);
assertTrue("Not Equals", data.equals(d));
};
db.giveUserDataToProcessors(data.getUuid(), process);
}
/**
* @throws SQLException
*/
@Test
public void testNicknameInjection() throws SQLException {
db.init();
UserData data = MockUtils.mockUser();
UserData data2 = MockUtils.mockUser2();
db.saveUserData(data2);
data.addNickname("s); DROP TABLE plan_users;--");
db.saveUserData(data);
assertTrue("Removed Users table.", db.getUsersTable().getUserId(data2.getUuid().toString()) != -1);
}
/**
* @throws SQLException
* @throws java.net.UnknownHostException
*/
@Test
public void testSaveMultipleUserData() throws SQLException, UnknownHostException {
db.init();
UserData data = MockUtils.mockUser();
data.getGmTimes().setAllGMTimes(5L, 10L, 15L, 20L);
// TODO data.getWorldTimes().setTime("World", 20L);
data.addIpAddress(InetAddress.getByName("185.64.113.61"));
data.addSession(new SessionData(1286349L, 2342978L));
data.addNickname("TestNick");
data.addPlayerKill(new KillData(MockUtils.getPlayer2UUID(), 2, "DiamondSword", 75843759L));
System.out.println(data.toString());
db.saveUserData(data);
data.getPlayerKills().clear();
System.out.println(data.toString());
data.addNickname("TestUpdateForSave");
UserData data2 = MockUtils.mockUser2();
data2.getGmTimes().setAllGMTimes(5L, 10L, 15L, 20L);
data2.addNickname("Alright");
data.addNickname("TestNick2");
data2.addIpAddress(InetAddress.getByName("185.64.113.60"));
data2.addSession(new SessionData(2348743L, 4839673L));
data2.addPlayerKill(new KillData(MockUtils.getPlayerUUID(), 1, "DiamondSword", 753759L));
List<UserData> list = new ArrayList<>();
list.add(data);
list.add(data2);
db.saveMultipleUserData(list);
data.addPlayerKill(new KillData(MockUtils.getPlayer2UUID(), 2, "DiamondSword", 75843759L));
List<UserData> userDataForUUIDS = db.getUserDataForUUIDS(MockUtils.getUUIDs());
System.out.println("\nData1:" + data.toString());
System.out.println("Data2:" + data2.toString() + "\n");
for (UserData uData : userDataForUUIDS) {
System.out.println("uData:" + uData.toString());
assertTrue("Not Equals", (data.equals(uData) || data2.equals(uData)));
}
}
/**
* @throws SQLException
*/

4
Plan/test/test/java/main/java/com/djrapitops/plan/utilities/analysis/AnalysisUtilsTest.java
View File

@ -123,8 +123,8 @@ public class AnalysisUtilsTest {
@Test
public void testTransformSessionDataToLengths() {
Collection<SessionData> data = new ArrayList<>();
data.add(new SessionData(0, 5L));
data.add(new SessionData(0, 20L));
data.add(new SessionData(0L, 5L, null, null, 0, 0));
data.add(new SessionData(0, 20L, null, null, 0, 0));
data.add(new SessionData(0));
List<Long> expResult = new ArrayList<>();
expResult.add(5L);

37
Plan/test/test/java/utils/MockUtils.java
View File

@ -3,11 +3,6 @@ package test.java.utils;
import com.djrapitops.plugin.utilities.player.Fetch;
import com.djrapitops.plugin.utilities.player.IPlayer;
import com.sun.net.httpserver.HttpServer;
import main.java.com.djrapitops.plan.data.KillData;
import main.java.com.djrapitops.plan.data.SessionData;
import main.java.com.djrapitops.plan.data.UserData;
import main.java.com.djrapitops.plan.data.time.GMTimes;
import main.java.com.djrapitops.plan.utilities.NewPlayerCreator;
import org.bukkit.GameMode;
import org.bukkit.Location;
import org.bukkit.World;
@ -16,9 +11,7 @@ import org.bukkit.entity.Player;
import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.UnknownHostException;
import java.util.HashSet;
import java.util.Set;
import java.util.UUID;
@ -39,36 +32,6 @@ public class MockUtils {
return mockWorld;
}
public static UserData mockUser() {
return NewPlayerCreator.createNewPlayer(mockIPlayer());
}
public static UserData mockUserWithMoreData() {
UserData mock = mockUser();
try {
mock.addIpAddress(InetAddress.getByName("247.183.163.155"));
} catch (UnknownHostException ignored) {
/* Ignored */
}
mock.addNickname("MoreNicks");
mock.addPlayerKill(new KillData(getPlayer2UUID(), 1, "WEP", 126873643232L));
mock.addSession(new SessionData(12345L, 23456L));
GMTimes gmTimes = mock.getGmTimes();
gmTimes.setAllGMTimes(1234, 2345, 4356, 4767);
gmTimes.setState("ADVENTURE");
mock.setDeaths(5);
mock.setTimesKicked(5);
mock.setPlayTime(34438926);
mock.setGeolocation("Finland");
mock.setLoginTimes(5);
mock.setMobKills(5);
return mock;
}
public static UserData mockUser2() {
return NewPlayerCreator.createNewPlayer(mockIPlayer2());
}
/**
* @return
*/

14
Plan/test/test/java/utils/RandomData.java
View File

@ -6,7 +6,6 @@ import main.java.com.djrapitops.plan.data.UserData;
import main.java.com.djrapitops.plan.data.WebUser;
import main.java.com.djrapitops.plan.data.handling.info.HandlingInfo;
import main.java.com.djrapitops.plan.data.handling.info.InfoType;
import main.java.com.djrapitops.plan.data.time.GMTimes;
import main.java.com.djrapitops.plan.utilities.PassEncryptUtil;
import main.java.com.djrapitops.plan.utilities.analysis.Point;
import org.apache.commons.lang.RandomStringUtils;
@ -25,17 +24,6 @@ public class RandomData {
return ThreadLocalRandom.current().nextInt(rangeStart, rangeEnd);
}
public static List<UserData> randomUserData() {
List<UserData> test = new ArrayList<>();
for (int i = 0; i < 20; i++) {
String randomName = randomString(10);
UserData uD = new UserData(UUID.randomUUID(), r.nextLong(), r.nextBoolean(), GMTimes.getGMKeyArray()[r.nextInt(3)], randomName, r.nextBoolean());
uD.setLastPlayed(r.nextLong());
test.add(uD);
}
return test;
}
public static String randomString(int size) {
return RandomStringUtils.random(size);
}
@ -61,7 +49,7 @@ public class RandomData {
public static List<SessionData> randomSessions() {
List<SessionData> test = new ArrayList<>();
for (int i = 0; i < 20; i++) {
test.add(new SessionData(r.nextLong(), r.nextLong()));
test.add(new SessionData(r.nextLong(), r.nextLong(), null, null, 0, 0));
}
return test;
}