All Classes and Interfaces
Class
Description
Abstract class representing a Database.
Represents plan_access_log table.
Represents Activity index of a player at a certain date.
Queries for Activity Index that attempts to gain insight into player activity levels.
Pie about different Activity Groups defined by ActivityIndex.
In charge of address management.
Shared Adventure
MessageBuilder shared by Velocity and Sponge.Keeps track how long player has been afk during a session
Special filter only used in cases where no filters are specified.
Deprecated.
PluginData API has been deprecated - see https://github.com/plan-player-analytics/Plan/wiki/APIv5---DataExtension-API for new API.
Deprecated.
AnalysisContainer is no longer used.
Deprecated.
AnalysisContainer can no longer be obtained, so this is deprecated.
Command argument mutation and access utility.
Service for resolving json asynchronously in order to move database queries off server thread.
Interface for different WebUser authentication methods used by Requests.
Utility for averaging data.
Data class for Average ping during a timespan (defined by the container).
Transaction that performs a clear + copy operation to duplicate a source database in the current one.
Patch that resets AFK time of sessions with afk time of length of the session to 0.
Patch that removes player IPs that were gathered as join address on Fabric.
Patch to fix incorrect register dates for nukkit.
Throw this exception when a Resolver gets invalid query for JSON.
Deprecated.
PluginData API has been deprecated - see https://github.com/plan-player-analytics/Plan/wiki/APIv5---DataExtension-API for new API.
Transaction to update a player's ban status.
Factory class for Bar Graphs.
Utility for performing Base64 operations.
Represents user information stored in plan_users.
Queries for
BaseUser objects.Method annotation to provide a boolean value.
Setting implementation for String value settings.
Listener that keeps track of actions that are not considered being AFK.
ConfigSystem for Bukkit.
Bukkit Database system that initializes SQLite and MySQL database objects.
Generic importer for user data into Plan on the Bukkit platform.
Task that handles player ping calculation on Bukkit based servers.
Dagger module for binding Plan instance.
ServerProperties for Bukkit.
Dagger module for Bukkit ServerProperties.
ServerShutdownSave implementation for Bukkit based servers.
Module for binding Bukkit specific classes as interface implementations.
UserImportRefiner attempts to find any crucial information that is missing.
Task that handles player ping calculation on Bungee based servers.
Dagger module for binding PlanBungee instance.
Manages Server information on the Bungee instance.
ServerProperties for Bungee.
Dagger module for Bungee ServerProperties.
Module for binding Bungee specific classes as interface implementations.
Formatter for amount of Megabytes (MB)
System that holds data caches of the plugin.
Caching layer between Supplier and caller.
Represents an entry for FullCalendar json calendar.
Factory class for different objects representing HTML calendars.
Interface for manually calling update methods on a registered
DataExtension.Implementation for
Caller interface.Enum representing different events when Plan calls methods of
DataExtension automatically.Service for figuring out provided API capabilities.
Singleton instance implementation for
CapabilityService.Intends to correct UUID of a user.
Formats chat messages in different ways.
Event Listener for AsyncPlayerChatEvents.
Event Listener for AsyncPlayerChatEvents.
Event Listener for chat events.
Formatter for a timestamp that only includes a clock.
Enum to determine what color to use for some element.
Deprecated.
This Class exists to keep plugins that used PluginData from breaking.
Class that contains ChatColors for plugins.
Intends to correct UUID of a user.
Lang implementation for general command language.Patch that removes plan_commandusages table.
Deprecated, for removal: This API element is subject to removal in a future version.
Plan API v4 has been deprecated, use the APIv5 instead (https://github.com/plan-player-analytics/Plan/wiki/APIv5).
Class holding Key objects that are commonly used across multiple DataContainers.
Class that allows performing most commonly wanted queries.
Exception to throw when a
Filter results in a complete set.A Minecraft message component.
Method annotation to provide a Minecraft text
Component value.A utility api class for dealing with rich and less-rich Minecraft message formats.
Implementation for
ComponentService.Utility Resolver for organizing resolution in a tree-like structure.
Method Annotation to determine that a method can not be called unless a condition is fulfilled.
Utility object for managing conditions.
Configuration utility for storing settings in a .yml file.
Represents a change made to the config structure.
Represents a single node in a configuration file
Reader for parsing
Config out of file-lines.Task that stores a server config in the database on boot.
System for Config and other user customizable options.
Class in charge of updating config.yml.
Utilities for parsing config values.
Writer for parsing
Config into file-lines.Static method class for queries that return some kind of
DataContainer.Deprecated.
PluginData API has been deprecated - see https://github.com/plan-player-analytics/Plan/wiki/APIv5---DataExtension-API for new API.
Contains list of contributors to add to the about modal.
Table information about 'plan_cookies'
Transaction that creates the database index if it has not yet been created.
SQL Builder creating statements for table creation, removal and modification.
Transaction that creates the table schema of Plan database.
Interface for interacting with a Plan SQL database.
Possible State changes:
CLOSED to PATCHING (Database init),
PATCHING to OPEN (Database initialized),
OPEN to CLOSING (Database closing),
CLOSING to CLOSED (Database closed),
PATCHING to CLOSED (Database closed prematurely)
Setting values that are in "Database" section.Method annotation to provide a
ExtensionDataBuilder.Interface for an object that can store arbitrary data referenced via
Key objects.Interface to implement data extensions with.
Exception that is thrown when a call to a DataExtension method throws an exception.
Setting values that are in "Data_gathering" section.Enum for different JSON data entries that can be stored in cache.
Representation of all values a Provider annotation provides.
Static method class for single item store queries.
Represents a value given to
ExtensionDataBuilder.Object that can be called to place data about players to the database.
Abstract formatter for a timestamp.
Interface for objects that have a epoch ms date.
Formatter for a DateHolder object that uses a different formatter.
Compares DateHolder objects so that most recent is last.
Compares DateHolder objects so that most recent is first.
Basic TreeMap that uses Epoch MS as keys.
Object that has a value tied to a date.
Formatter for a timestamp which includes days as the smallest entry.
Database Lock that prevents queries and transactions from taking place before database schema is ready.
Task for cleaning the active database.
Database is closed and exception is needed to stop execution, not to be logged.
Thrown when something goes wrong with
Database#init.The task which handles the upkeep of the
ConnectionRuntime exception for wrapping database errors.
System that holds the active databases.
An enum which stores the name, the config name and if the Database supports MySQL Queries
Event Listener for EntityDeathEvents.
Event Listener for detecting player and mob deaths.
Formatter for decimal points that depends on settings.
Lang implementation for in depth help language when /command ? is used.Contains width of characters in the chat with default font.
Patch that replaces plan_ips with plan_geolocations table.
Represents a data-point given by a Provider method of a DataExtension.
Adds disk usage information to tps table.
Setting values that are in "Display_options" section.Method annotation to provide a double value.
Setting implementation for Double (floating point) value settings.
DataContainer implementation that delegates the method calls to other DataContainer implementations.
Deprecated.
Table html generation is to be done in frontend in the future.
Enum representing big elements of a plugin.
Thrown when something goes wrong with Plan initialization.
Formatter for entity names, that capitalizes the first word and removes symbols.
Contains context for an error that might help debugging it.
Page to display error stacktrace.
Lang implementation for all error pages.SQL executing batch statement that closes appropriate elements.
SQL executing statement that closes appropriate elements.
Interface for everything that updates rows in the database.
Handles export for different pages.
Exception thrown by
Exporter if something goes wrong with export.Export utility that takes care of path replacement for different resources referenced in other files.
Schedules export tasks so that they are not all run at once.
Setting values that are in "Export" section.System in charge of exporting html.
Query for selecting a percentage of true for each boolean provided for players.
Query for selecting average and total for each double value provided for players.
Query for selecting Tables out of groups for players.
Query for selecting average and total for each number value provided for players.
Query for selecting average for each percentage value provided for players.
Represents boolean data returned by a BooleanProvider method.
Represents component data returned by a ComponentProvider method.
Represents data of a single extension about a server.
Builder API for Extension data.
Describes information about an extension value given by a Provider method.
Represents double data returned by a DoubleProvider or PercentageProvider method.
Implementation detail, for extracting methods from
DataExtension.Table information about 'plan_extension_groups'.
Table information about 'plan_extension_icons'.
Information about a DataExtension stored in the database.
Queries for information about DataExtensions stored in the database.
Implementation detail, abstracts away some method reflection to a more usable API.
Implementation detail, abstracts away method type reflection to a more usable API.
Represents double data returned by a DoubleProvider or PercentageProvider method.
Query all ExtensionData by Server UUIDs.
Query player's Groups by Plugin ID inside ExtensionData objects.
Query player tables from tableprovider table.
Table information about 'plan_extension_user_table_values'.
Table information about 'plan_extension_user_values'.
Table information about 'plan_extension_plugins'.
Table information about 'plan_extension_providers'.
Query Extension data of x most recent players matching a query
In charge of registering built in
DataExtension implementations.Query ExtensionData of a server.
Task for updating
DataExtension server values periodically.Query Extension data of x most recent players on a server.
Query server tables from tableprovider table.
Table information about 'plan_extension_server_table_values'.
Table information about 'plan_extension_server_values'.
Interface for registering
DataExtensions.Class responsible for generating and generating settings for DataExtensions to the config.
Patch to add 'show_in_players_table' to 'plan_extension_providers'
Represents double data returned by a DoubleProvider or PercentageProvider method.
Implementation for
ExtensionService.Represents data on an extension tab.
Represents table data from a single TableProvider.
Adds format_1 to _5 fields to plan_extension_tables table.
Table information about 'plan_extension_tables'.
Adds values_for field to plan_extension_tables
Increases the length of Strings in extension tables to 250 to avoid cutoffs and exceptions.
Table information about 'plan_extension_tabs'.
Represents information defined in a
DataExtension class.Config system for Fabric.
Fabric database system that initializes the required SQLite and MySQL database objects.
Interface for all listeners on the Fabric platform.
Listener system for the Fabric platform.
Task that handles player ping calculation on Fabric based servers.
server.properties fetcher for Fabric
Dagger module for providing ServerProperties on Fabric.
ServerShutdownSave implementation for Fabric-based servers.
Module for binding Fabric-specific classes as interface implementations.
System for checking if new Version is available when the System initializes, altering the link for Fabric.
Reason for WebUserAuthException.
Enum to determine font-awesome icon family.
Deprecated.
This Class exists to keep plugins that used PluginData from breaking.
Class for watching files for changes.
Represents a query filter for /query page.
Represents a query filter.
Setting values that are in "Formatting" section.Interface for formatting a value into a String.
Factory for new instances of different
Formatters.Enum for determining additional formatter for a value given by a
NumberProvider.Event Listener for PlayerGameModeChangeEvents.
Event Listener for PlayerGameModeChangeEvents.
Event Listener for PlayerGameModeChangeEvents.
Lang implementation for single words.Data class that contains information about IP and Geolocation.
Comparator for comparing GeoInfo so that most recent is the first component.
Adds last_used field to the geolocation table.
Mutator for lists of GeoInfo objects.
Replaces user_id foreign keys with user_uuid fields in geolocation table.
Queries for
GeoInfo objects.Table information about 'plan_ips'.
Geolocator implementation for MaxMind GeoLite2 database.This class contains the geolocation cache.
Interface for different Geolocation service calls.
TimeKeeper class that tracks the time spent in each GameMode based on Playtime.
Creates Graph related Data JSON.
Factory class for different objects representing HTML graphs.
Resolves /v1/graph JSON requests.
Method parameter for providing values about a group with provider annotations.
Method annotation to provide
String[] array of Group names about a Player.SQL query of a COUNT statement that closes proper elements.
Lang for short help messages in Commands.
Interface for Graphs with HighCharts data support.
Lang enum for all text included in the html files.
Deprecated.
Table html generation is to be done in frontend in the future.
Deprecated.
Table html generation is to be done in frontend in the future.
Formats timestamps to the Last-Modified header time format.
Object that represents an icon on the website.
Deprecated.
This Class exists to keep plugins that used PluginData from breaking.
Deprecated.
This Class exists to keep plugins that used PluginData from breaking.
Utility for getting server identifier from different sources.
Abstract representation of an ImportSystem.
Represents parameters for a single
Filter parsed from the query json.Deprecated.
PluginData API has been deprecated - see https://github.com/plan-player-analytics/Plan/wiki/APIv5---DataExtension-API for new API.
Setting implementation for String value settings.
Page to display error stacktrace.
Represents a HTTP request.
Annotation used to invalidate old method values.
Formatter for a timestamp in ISO-8601 format without the clock.
Formatter for a timestamp in ISO-8601 format without the clock, without applying timezone offset.
Formatter for Item names, that capitalizes each part and separates them with spaces instead of underscores.
Resource implementation for something that is read via InputStream.Formats epoch milliseconds to the date format Javascript Date constructor expects.
Represents a single join address - number pair.
Lang enum for all text included in the javascript files.
Factory with different JSON creation methods placed to a single class.
In charge of storing json files on disk for later retrieval.
In charge of storing json somewhere for later retrieval.
Identifier used for storing and fetching data from DataContainers.
Transaction to store information in the database when a player is kicked from the server.
Queries for
PlayerKill objects.Replaces killer_id, victim_id and server_id foreign keys with respective uuid fields in kills table.
Adds server_id field to kills table.
Table information about 'plan_kills'.
Interface for splitting different Language categories into different classes.
Language enum of supported languages, follows ISO 639-1 for language codes.
Static method class for queries that use large amount of memory.
Static method class for large storage queries.
This is a LineGraph for any set of Points, thus it is Abstract.
Factory class for different objects representing HTML line graphs.
Implementation of commands that send a link to the command sender.
Adds linked_to_uuid field to plan_security table that stores web users.
Populates new linked_to_uuid field with the uuid of a username (same as minecraft name) or 'console'.
Service for registering listeners as Plan.
Methods that can be used as functional interfaces when dealing with Maps.
Removes invalid data caused by https://github.com/plan-player-analytics/Plan/issues/1355.
Represents loaded language information.
Compares Locale Map Entries and sorts them alphabetically according to the Enum Names.
Utility for reading locale files.
Utility for writing a Locale into a file.
Resolves JSON requests for /v1/locale and /v1/locale/
Enum.toString().System in charge of
Locale.Html String generator for /login and /register page.
Task in charge of removing old log files
Methods that can be used as functional interfaces when dealing with Maps.
Calculates maximum from given values.
Math utility for calculating the median from Integer values.
Represents a Message that can be modified by the caller.
Deprecated.
Old implementation used this.
Utility enum for determining what kind of parameters a provider method used.
Wrap a Method so that it is easier to call.
Utility method class containing various static methods.
Processor Class for KillEvent information when the killer is a
player.
Static method class for MySQL Schema related queries.
Represents a FOREIGN KEY constraint in a MySQL database.
Html utility for creating navigation link html.
Queries for Activity Index that attempts to gain insight into player activity levels.
Task on networks that stores server configs in /plugins/Plan/serverConfiguration in database on boot.
Resolves /v1/network/ JSON requests.
Creates JSON payload for /network-page Network Overview tab.
Html String generator for /network page.
Handles exporting of /network page html, data and resources.
Creates JSON payload for /server-page Performance tab.
Creates JSON payload for /network-page Playerbase Overview tab.
Creates JSON payload for /network-page Sessions tab.
In charge of updating network-server configs.
Interface for different tab JSON creators.
Functional interface wrapper for resolving network JSON directly from other methods.
Query for displaying players on /players page.
Query to fetch a newer config from the database.
Object storing nickname information.
Used for caching nicknames when the player is online.
Adds last_seen to nickname table by populating it with the data in actions table, and removes the actions table.
Queries for
Nickname objects.Replaces user_id and server_id foreign keys with respective uuid fields in nickname table.
Table information about 'plan_nicknames'.
Special Resolver that gives responses without user authentication.
In charge of disabling Webserver if a Proxy server is detected in the database.
Throw this exception when a Resolver can not resolve a path.
Exception to throw inside DataExtension if a method is not ready to be called (Data is not available etc).
Listener that keeps track of actions that are not considered being AFK.
ConfigSystem for Bukkit.
Nukkit Database system that initializes SQLite and MySQL database objects.
Task that handles player ping calculation on Nukkit based servers.
Placeholder expansion used to provide data from Plan on Nukkit.
Dagger module for binding Plan instance.
ServerProperties for Nukkit.
Dagger module for Nukkit ServerProperties.
ServerShutdownSave implementation for Nukkit based servers.
Module for binding Nukkit specific classes as interface implementations.
Method annotation to provide a long (64bit number) value.
Creates JSON payload for /server-page Online Activity Overview tab.
Transaction that is required to be executed before a database is operable.
Placeholders about operators.
Transaction to update a player's operator status.
Utility for loading version information from Ore, Sponge's plugin repository
Interface for generating page HTML String.
Factory for creating different
Page objects.Guards against password brute-force break attempts.
Password Encryption utility.
Formatter for percentages.
Method annotation to provide a double (Percentage).
Creates JSON payload for /server-page Performance tab.
Permissions class is used easily check every permission node.
Static method class for queries that count together counts for a player on a per server basis.
Container for data about a player linked.
Used to get a PerServerContainer for a specific player.
Key objects for PerServerContainer container.
Mutator for PerServerContainer object.
This is a PieChart for any set of PieSlices, thus it is Abstract.
Factory class for different objects representing HTML pie graphs.
Represents a slice of a pie.
Comparator for PieSlices to descending Percentage order.
PieChart with a Pie about each slice as well.
Replaces uuid and server_uuid with foreign keys in ping table.
Queries for
Ping objects.Transaction to store player's Ping value on a server.
Table information about 'plan_ping'.
Special Key object that can be used for placeholders when replacing values in html files.
Module for the Placeholder API related objects.
Formatter for replacing ${placeholder} values inside strings.
Main class for Bukkit that manages the plugin.
Deprecated.
Plan API v4 has been deprecated, use the APIv5 instead (https://github.com/plan-player-analytics/Plan/wiki/APIv5).
Dagger Component that constructs the plugin systems running on Bukkit.
Event that is called when Plan is enabled.
Bungee Main class.
Dagger Component that constructs the plugin systems running on Bungee.
Event that is called when Plan is enabled.
ColorScheme that uses values in config settings specific to Plan or PlanBungee.
Plan configuration file.
Main class for Plan's Fabric version.
Dagger component for constructing the required plugin systems on Fabric.
Abstracts File methods of Plugin classes so that they can be tested without Mocks.
Main class for Nukkit that manages the plugin.
Dagger Component that constructs the plugin systems running on Nukkit.
Placeholder expansion used to provide data from Plan on Bukkit.
Registry for all placeholders.
Abstraction interface for both Plan and PlanBungee.
Dagger Component that constructs the plugin systems running on Sponge.
Event that is called when Plan is enabled.
PlanSystem contains everything Plan needs to run.
Velocity Main class.
Dagger Component that constructs the plugin systems running on Velocity.
Event that is called when Plan is enabled.
Dagger module for defining Platform Abstraction Layer utilities.
Creates JSON payload for /server-page Playerbase Overview tab.
Utility for creating FullCalendar calendar event array on Player page.
Deprecated.
Plan API v4 has been deprecated, use the APIv5 instead (https://github.com/plan-player-analytics/Plan/wiki/APIv5).
DataContainer about a Player.
Used to get a PlayerContainer of a specific player.
Queries for server overview tab data.
Static method class for queries that return information related to a single player.
Handles exporting of player json.
Class that holds Key objects for PlayerContainer.
Represents a player vs player kill.
Mutator functions for
PlayerKill objects.Processor Class for KillEvent information when the killer is a
player.
Resolves /v1/kills JSON requests.
Event Listener for PlayerJoin, PlayerQuit and PlayerKickEvents.
Player Join listener for Bungee.
Event Listener for PlayerJoin, PlayerQuit and PlayerKickEvents.
Listener for Player Join/Leave on Sponge.
Player Join listener for Velocity.
Html String generator for /player page.
Handles exporting of /player page html, data and resources.
Resolves /player/${name/uuid} URLs.
Placeholders about a player.
Responsible for generating /player page plugin tabs based on DataExtension API data.
Transaction for registering player's BaseUser to the database.
Mutator for a bunch of
PlayerContainers.Resolves dates into players online numbers with a help of a NavigableMap.
Html String generator for /players page.
Handles exporting of /players page html, data and resources.
Resolves /players URL.
Utility for creating jQuery Datatables JSON for a Players Table.
Resolves /v1/players JSON requests.
Deprecated.
PluginData API has been deprecated - see https://github.com/plan-player-analytics/Plan/wiki/APIv5---DataExtension-API for new API.
New logger that logs errors to specific files.
Class Annotation for informing Plan about a plugin.
Lang implementation for Language that is logged when the plugin enables or disables.Setting values that are in "Server" or "Plugin" section.Comparator for Points for ascending x value order.
Utility class for different Predicates used in the plugin.
Illegal State somewhere during preparation.
Represents the annotation information provided on a method.
ConfigSystem for Bungee.
Bungee Database system that initializes MySQL object.
Setting values that are in "Database" section.Dagger module for binding proxy server classes to super classes.
TPSCounter extension for game server platforms.
Access to public_html folder and its contents.
Resolves any files in public_html folder.
Bubble Chart that represents login "punches" of players.
Creates JSON payload for /server-page PvP and PvE tab.
Query utility for extracting Tabs.
Query utility for extracting Tables.
Interface for everything that returns results from the database.
SQL query that doesn't require preparing that closes proper elements.
Contains a single instance of each filter kind.
Page to display error stacktrace.
Service for Query API.
See https://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html
See https://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html
See https://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html
SQL query that closes proper elements.
Query for displaying players on /query page players table.
DataContainer that stores everything as raw object value.
Exporter in charge of exporting React related files.
Represents React index.html.
Utility class for checking if RedisBungee API is available.
Players online supplier when using RedisBungee.
Allows using ReentrantLock with lambdas.
An utility class that simplifies reflection in Bukkit plugins.
An interface for retrieving the field content.
Changes register dates on networks to the smallest number found in the database.
Holds registrations of users before they are confirmed.
Takes care of data without foreign keys that is missing the foreign key target in plan_servers.
Takes care of data without foreign keys that is missing the foreign key target in plan_users.
Transaction for removing duplicate data in plan_user_info.
Transaction that removes everything from the database.
Removes incorrectly formatted package data from the database.
Transaction to remove method results that correspond to
InvalidateMethod annotations.Transaction that removes outdated plugin's data after configurable threshold.
Transaction for cleaning up old data from the database.
Transaction for removing a player's data from the database.
Transaction to remove older results that violate an updated condition value.
Transaction to remove older results that violate an updated condition value.
Sets username fields to NULL in plan_access_log table.
Transaction to remove a Plan
User from the database.Represents a HTTP request to use with
Resolver.Interface for resolving requests of Plan webserver.
Service for modifying webserver request resolution.
ResolverService Implementation.
Interface for accessing plugin resources in jar or plugin files.
In-memory cache for different resources on disk or jar.
Service for making plugin resources customizable by user or Plan API.
ResourceService implementation.
Task in charge of writing html customized files on enable when they don't exist yet.
Represents a response that will be sent over HTTP.
Thrown when
ResponseBuilder is missing some parameters.Factory for creating different
Response objects.Resolves All URLs.
Utility class for player retention calculations.
Root resolver for JSON requests, resolves /v1/ URLs.
Resolves '/' URL (Address Root).
Service for registering async tasks as Plan.
Formatter for timestamp which includes seconds as the smallest entry.
Table information about 'plan_security'
Represents a Server that is running Plan.
Utility for creating JSON for Server Accordion
Static method class for queries that count how many entries of particular kinds there are for a server.
Utility for creating FullCalendar calendar event array on Player page.
Deprecated, for removal: This API element is subject to removal in a future version.
Plan API v4 has been deprecated, use the APIv5 instead (https://github.com/plan-player-analytics/Plan/wiki/APIv5).
Represents outgoing server information json.
SubSystem for managing Server information.
Adds a is_proxy field to remove technical debt assuming name field "BungeeCord" being the proxy.
Interface for operating on server information.
Creates JSON payload for /server-page Server Overview tab.
Html String generator for /server page.
Handles exporting of /server page html, data and resources.
Resolves /network, /server and /server/${name/uuid} URLs.
Placeholders about a servers.
Responsible for generating /server page plugin tabs based on DataExtension API data.
Class responsible for holding server variable values that do not change
without a reload.
Queries for
Server objects.Allows sensing values from different server platforms.
Manages the Server UUID for Bukkit servers.
In charge of updating server-network config.
Class in charge of performing save operations when the server shuts down.
Transaction to store sessions on server shutdown.
Interface using Server UUID for creating Objects that can be turned into JSON with Gson.
Functional interface wrapper for resolving server specific JSON directly from other methods.
Table information about 'plan_servers'.
Query for displaying players on /server page players tab.
TPSCounter extension for game server platforms.
Adds afk_time field to sessions table.
This class is used to store active sessions of players in memory.
Query to fetch server id for each session, used by 2 patches.
Adds join_address_id to plan_sessions, and populates latest session rows with value from plan_user_info.
Placeholders about sessions.
Queries for
FinishedSession objects.Resolves /v1/sessions JSON requests.
Mutator for a list of Sessions.
Replaces user_id and server_id foreign keys with respective uuid fields in sessions table.
Creates JSON payload for /server-page Sessions tab.
Table information about 'plan_sessions'.
Comparator for Sessions in descending start order (Most recent first).
Transaction for telling Plan that Plan has been uninstalled from the server.
Represents a path to a config value.
Service for defining plugin specific settings to the Plan config.
Implementation for
SettingsService.Table information about 'plan_settings'.
Thread that is run when JVM shuts down.
Delegates org.slf4j.Logger (unrelocated) to plan.org.slf4j.Logger (relocated).
Factory class for different objects representing special HTML graphs.
Listener that keeps track of actions that are not considered being AFK.
Listener that keeps track of player display name.
Sponge ConfigSystem that disables Geolocations on first enable.
DBSystem for Sponge.
Listener for Deaths and Kills on Sponge.
Listener for GameMode change on Sponge.
Task that handles player ping calculation on Sponge based servers.
Implements jar resource fetching with Sponge Asset API.
ServerProperties for Sponge.
Dagger module for Sponge ServerProperties.
ServerShutdownSave implementation for Sponge
Module for binding Sponge specific classes as interface implementations.
System for checking if new Version is available when the System initializes, using the Ore API.
Listener for World change on Sponge.
Duplicate String reducing utility class for SQL language Strings.
Class for building different SQL strings.
Class containing main logic for different data related save and load functionality.
Static method class for SQLite Schema related queries.
Represents a value set for a Stack graph.
Utility for creating HighCharts Stack graphs.
Factory class for different objects representing HTML stack graphs.
Resolves all static resources for the pages.
Transaction to store a server's configuration file in the database.
Transaction to update Geo information of a player in the database.
Transaction to store an Icon to the database.
Transaction to store player's nickname information in the database.
Transaction to store method result of a boolean.
Transaction to store method result of.
Transaction to store method result of player's groups.
Transaction to store method result of a long.
Transaction to store method result of a String.
Transaction to store method result of a Table.
Transaction to update command usage information in the database.
Transaction to store information about a simple
DataProvider.Transaction to store method result of a boolean.
Transaction to store method result of a double.
Transaction for keeping Plan Server information up to date in the database.
Transaction to store method result of a long.
Transaction for registering player's BaseUser and UserInfo to the database.
Transaction to store Extension String data for a server.
Transaction to store method result of a Table.
Transaction for storing a session after a session has ended.
Transaction for storing
TabInformations.Transaction to store information about a Table.
Transaction to save a new Plan
User to the database.Transaction to store world name after an event.
Resource decorator to cache result of asString method call in
ResourceCache.Compares Strings and sorts them by length (Longest fist).
Setting implementation for String value settings.
Method annotation to provide a String value.
Setting implementation for String value settings.
Represents a system that can be enabled and disabled.
DataContainer implementation that stores everything in
Supplier objects.Module for binding object instances found inside other systems.
Utility class for obtaining System usage statistics.
Task for performing system resource usage checks asynchronously
Method Annotation for determining Tab the given element should appear on.
In charge of holding tab completion data for commands, as tab completion is done on server thread.
Class Annotation that allows determining an Icon and
ElementOrder of a tab.Object for giving Plan table data.
Factory for creating new
Table objects.Utility for accessing implementation variables inside
Table.Factory object.Deprecated.
PluginData API has been deprecated - see https://github.com/plan-player-analytics/Plan/wiki/APIv5---DataExtension-API for new API.
Represents a player displayed on a player table on players tab or /players page.
Method annotation to provide a Table.
Class Annotation for informing Plan about plugin's tab order preference.
Represents a structural HTML element that has Tabs on the top.
TaskSystem that registers tasks for the plugin.
Enum that contains available themes.
Config that keeps track of theme.yml.
Enum class used for getting the Html colors that match the config settings.
Utilities for manipulating different Throwable stack traces.
Transaction that can be thrown away if it is in execution when the database is closing.Functional interface that performs an operation that might throw an exception.
Functional interface that performs an operation that might throw an exception.
Functional interface that performs an operation that might throw an exception.
Formatter for time amount in milliseconds.
Keeps track of time spent in each state.
Utility for averaging time based data.
Setting implementation for settings that use
TimeUnit under the value.Setting values that are in "Time" section.Utility for getting a
TimeZone from Plan FormatSettings.TIMEZONE value.Class containing single datapoint of TPS / Players online / CPU Usage / Used Memory / Entity Count / Chunks loaded.
Builder for TPS to make it easier to manage.
Utility for calculating TPS using nano time.
Compares TPS objects so that earliest is first.
Class responsible for calculating TPS every second.
Mutator for a list of TPS data.
Queries for
TPS objects.Transaction to store server's TPS data.
Table information about 'plan_tps'.
Represents a database transaction.
Removes plan_transfer table, used for transferring html in the database.
Represents a trend in the data - used for JSON format.
Functional interface for three arguments, similar to BiConsumer.
Similar to Google's TypeToken but without requiring whole gson package.
Utility for combining multiple UnaryOperator modifications.
Synchronizes a critical section of code so that only a single thread can access it at a time.
Annotation for identifying untrusted data that has not been sanitized.
Represents URI parameters described with
?param=value¶m2=value2 in the URL.Represents a registered user in the database.
Queries for fetching different user identifiers in the database.
Represents user information stored in plan_user_info.
Make sure hostname can be null.
Patch to add 'hostname' to 'plan_user_info'
Replaces user_id and server_id foreign keys with respective uuid fields in user info table.
Queries for
UserInfo objects.Table information about 'plan_user_info'.
Table information about 'plan_users'.
Utility for fetching a user's UUID.
Used for building
DataValues for ExtensionDataBuilder.addValue(Class, DataValue).Task that handles player ping calculation on Velocity based servers.
Dagger module for binding PlanVelocity instance.
Utility class for checking if RedisBungee API is available.
Players online supplier when using RedisBungee.
Manages Server information on the Velocity instance.
ServerProperties for Velocity.
Dagger module for Bungee ServerProperties.
Module for binding Velocity specific classes as interface implementations.
Table schema change patch for version 4.0.0 to support BungeeCord servers.
System for checking if new Version is available when the System initializes.
Data class for reading version.txt in https://github.com/AuroraLS3/Plan-PlayerAnalytics.
Utility for loading version information from github.
Resolves requests for /v1/version.
Removes the table schema versioning table.
Represents query page view that the user wants to see data for.
Functional interface that performs an operation that returns nothing.
File or Path with a function that is called if the file is modified.
Deprecated, for removal: This API element is subject to removal in a future version.
Html customization system will be overhauled for React version of frontend.
Represents a customizable resource.
Setting values that are in "Webserver" section.WebServer subsystem for managing WebServer initialization.
Deprecated.
Use
User instead
TODO Rewrite Authentication stuffThrown when WebUser can not be authorized (WebServer).
Queries for web user objects.
Represents a world stored in the Plan database.
Class responsible for managing config settings for World Aliases.
World Map that uses iso-a3 specification of Country codes.
Replaces server_id foreign keys with server_uuid field in world table.
Adds server_id field to worlds table.
Table information about 'plan_worlds'.
Placeholders about a world times.
Class that tracks the time spent in each World based on GMTimes.
Replaces server_id foreign keys with server_uuid field in world times table.
Queries for
WorldTimes objects.Adds server_id field to world times table.
Information about database table 'plan_world_times'.
Formatter for a timestamp which includes year, but not seconds.