Upstream/AuthMeReloaded
1
0
Fork 0
mirror of https://github.com/AuthMe/AuthMeReloaded.git synced 2024-12-24 17:47:38 +01:00
Code Issues Projects Releases Wiki Activity

#449 Migrate remaining non-group legacy Settings

Browse Source
This commit is contained in:
ljacqu 2016-07-23 14:44:52 +02:00
parent 476e0c197d
commit 18a9fbaa26
14 changed files with 119 additions and 127 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
src/main/java/fr/xephi/authme/AuthMe.java
View File

@ -30,11 +30,9 @@ import fr.xephi.authme.output.ConsoleFilter;
import fr.xephi.authme.output.Log4JFilter;
import fr.xephi.authme.output.MessageKey;
import fr.xephi.authme.output.Messages;
import fr.xephi.authme.permission.AuthGroupHandler;
import fr.xephi.authme.permission.PermissionsManager;
import fr.xephi.authme.permission.PermissionsSystemType;
import fr.xephi.authme.process.Management;
import fr.xephi.authme.security.PasswordSecurity;
import fr.xephi.authme.security.crypts.SHA256;
import fr.xephi.authme.settings.NewSetting;
import fr.xephi.authme.settings.Settings;
@ -55,6 +53,7 @@ import fr.xephi.authme.util.GeoLiteAPI;
import fr.xephi.authme.util.MigrationService;
import fr.xephi.authme.util.StringUtils;
import fr.xephi.authme.util.Utils;
import fr.xephi.authme.util.ValidationService;
import org.apache.logging.log4j.LogManager;
import org.bukkit.Bukkit;
import org.bukkit.Location;
@ -71,6 +70,7 @@ import org.bukkit.scheduler.BukkitScheduler;
import org.bukkit.scheduler.BukkitWorker;
import java.io.File;
import java.io.IOException;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collection;
@ -112,6 +112,7 @@ public class AuthMe extends JavaPlugin {
private BukkitService bukkitService;
private Injector injector;
private GeoLiteAPI geoLiteApi;
private PlayerCache playerCache;
/**
* Constructor.
@ -281,18 +282,20 @@ public class AuthMe extends JavaPlugin {
}
protected void instantiateServices(Injector injector) {
// Some statically injected things
injector.register(PlayerCache.class, PlayerCache.getInstance());
// PlayerCache is still injected statically sometimes
playerCache = PlayerCache.getInstance();
injector.register(PlayerCache.class, playerCache);
messages = injector.getSingleton(Messages.class);
permsMan = injector.getSingleton(PermissionsManager.class);
bukkitService = injector.getSingleton(BukkitService.class);
pluginHooks = injector.getSingleton(PluginHooks.class);
injector.getSingleton(PasswordSecurity.class);
spawnLoader = injector.getSingleton(SpawnLoader.class);
commandHandler = injector.getSingleton(CommandHandler.class);
management = injector.getSingleton(Management.class);
geoLiteApi = injector.getSingleton(GeoLiteAPI.class);
// Trigger construction of API classes; they will keep track of the singleton
injector.getSingleton(NewAPI.class);
injector.getSingleton(API.class);
}
@ -346,14 +349,13 @@ public class AuthMe extends JavaPlugin {
int playersOnline = bukkitService.getOnlinePlayers().size();
if (playersOnline < 1) {
database.purgeLogged();
} else if (Settings.reloadSupport) {
} else if (newSettings.getProperty(SecuritySettings.USE_RELOAD_COMMAND_SUPPORT)) {
for (PlayerAuth auth : database.getLoggedPlayers()) {
if (auth == null) {
continue;
if (auth != null) {
auth.setLastLogin(new Date().getTime());
database.updateSession(auth);
playerCache.addPlayer(auth);
}
auth.setLastLogin(new Date().getTime());
database.updateSession(auth);
PlayerCache.getInstance().addPlayer(auth);
}
}
}
@ -422,12 +424,12 @@ public class AuthMe extends JavaPlugin {
// Save player data
BukkitService bukkitService = injector.getIfAvailable(BukkitService.class);
LimboCache limboCache = injector.getIfAvailable(LimboCache.class);
AuthGroupHandler authGroupHandler = injector.getIfAvailable(AuthGroupHandler.class);
ValidationService validationService = injector.getIfAvailable(ValidationService.class);
if (bukkitService != null && limboCache != null) {
if (bukkitService != null && limboCache != null && validationService != null) {
Collection<? extends Player> players = bukkitService.getOnlinePlayers();
for (Player player : players) {
savePlayer(player, limboCache, authGroupHandler);
savePlayer(player, limboCache, validationService);
}
}
@ -492,7 +494,7 @@ public class AuthMe extends JavaPlugin {
// Stop/unload the server/plugin as defined in the configuration
public void stopOrUnload() {
if (Settings.isStopEnabled) {
if (newSettings == null || newSettings.getProperty(SecuritySettings.STOP_SERVER_ON_PROBLEM)) {
ConsoleLogger.warning("THE SERVER IS GOING TO SHUT DOWN AS DEFINED IN THE CONFIGURATION!");
getServer().shutdown();
} else {
@ -507,9 +509,10 @@ public class AuthMe extends JavaPlugin {
*
* @throws ClassNotFoundException if no driver could be found for the datasource
* @throws SQLException when initialization of a SQL datasource failed
* @throws IOException if flat file cannot be read
* @see AuthMe#database
*/
public void setupDatabase(NewSetting settings) throws ClassNotFoundException, SQLException {
public void setupDatabase(NewSetting settings) throws ClassNotFoundException, SQLException, IOException {
if (this.database != null) {
this.database.close();
}
@ -518,7 +521,7 @@ public class AuthMe extends JavaPlugin {
DataSource dataSource;
switch (dataSourceType) {
case FILE:
dataSource = new FlatFile();
dataSource = new FlatFile(this);
break;
case MYSQL:
dataSource = new MySQL(settings);
@ -530,10 +533,10 @@ public class AuthMe extends JavaPlugin {
throw new UnsupportedOperationException("Unknown data source type '" + dataSourceType + "'");
}
DataSource convertedSource = MigrationService.convertFlatfileToSqlite(newSettings, dataSource);
DataSource convertedSource = MigrationService.convertFlatfileToSqlite(settings, dataSource);
dataSource = convertedSource == null ? dataSource : convertedSource;
if (newSettings.getProperty(DatabaseSettings.USE_CACHING)) {
if (settings.getProperty(DatabaseSettings.USE_CACHING)) {
dataSource = new CacheDataSource(dataSource);
}
@ -560,11 +563,11 @@ public class AuthMe extends JavaPlugin {
}
// Save Player Data
private void savePlayer(Player player, LimboCache limboCache, AuthGroupHandler authGroupHandler) {
if (safeIsNpc(player) || Utils.isUnrestricted(player)) {
private void savePlayer(Player player, LimboCache limboCache, ValidationService validationService) {
final String name = player.getName().toLowerCase();
if (safeIsNpc(player) || validationService.isUnrestricted(name)) {
return;
}
String name = player.getName().toLowerCase();
if (limboCache.hasPlayerData(name)) {
limboCache.restoreData(player);
limboCache.removeFromCache(player);
@ -585,7 +588,7 @@ public class AuthMe extends JavaPlugin {
}
}
}
PlayerCache.getInstance().removePlayer(name);
playerCache.removePlayer(name);
}
private boolean safeIsNpc(Player player) {
@ -622,7 +625,7 @@ public class AuthMe extends JavaPlugin {
.replace("{ONLINE}", playersOnline)
.replace("{MAXPLAYERS}", Integer.toString(server.getMaxPlayers()))
.replace("{IP}", ipAddress)
.replace("{LOGINS}", Integer.toString(PlayerCache.getInstance().getLogged()))
.replace("{LOGINS}", Integer.toString(playerCache.getLogged()))
.replace("{WORLD}", player.getWorld().getName())
.replace("{SERVER}", server.getServerName())
.replace("{VERSION}", server.getBukkitVersion())

8
src/main/java/fr/xephi/authme/api/API.java
View File

@ -8,7 +8,7 @@ import fr.xephi.authme.hooks.PluginHooks;
import fr.xephi.authme.process.Management;
import fr.xephi.authme.security.PasswordSecurity;
import fr.xephi.authme.security.crypts.HashedPassword;
import fr.xephi.authme.util.Utils;
import fr.xephi.authme.util.ValidationService;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.entity.Player;
@ -29,18 +29,20 @@ public class API {
private static PasswordSecurity passwordSecurity;
private static Management management;
private static PluginHooks pluginHooks;
private static ValidationService validationService;
/*
* Constructor.
*/
@Inject
API(AuthMe instance, DataSource dataSource, PasswordSecurity passwordSecurity, Management management,
PluginHooks pluginHooks) {
PluginHooks pluginHooks, ValidationService validationService) {
API.instance = instance;
API.dataSource = dataSource;
API.passwordSecurity = passwordSecurity;
API.management = management;
API.pluginHooks = pluginHooks;
API.validationService = validationService;
}
/**
@ -77,7 +79,7 @@ public class API {
* @return true if the player is unrestricted
*/
public static boolean isUnrestricted(Player player) {
return Utils.isUnrestricted(player);
return validationService.isUnrestricted(player.getName());
}
public static Location getLastLocation(Player player) {

8
src/main/java/fr/xephi/authme/api/NewAPI.java
View File

@ -8,7 +8,7 @@ import fr.xephi.authme.hooks.PluginHooks;
import fr.xephi.authme.process.Management;
import fr.xephi.authme.security.PasswordSecurity;
import fr.xephi.authme.security.crypts.HashedPassword;
import fr.xephi.authme.util.Utils;
import fr.xephi.authme.util.ValidationService;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.entity.Player;
@ -29,18 +29,20 @@ public class NewAPI {
private final DataSource dataSource;
private final PasswordSecurity passwordSecurity;
private final Management management;
private final ValidationService validationService;
/*
* Constructor for NewAPI.
*/
@Inject
NewAPI(AuthMe plugin, PluginHooks pluginHooks, DataSource dataSource, PasswordSecurity passwordSecurity,
Management management) {
Management management, ValidationService validationService) {
this.plugin = plugin;
this.pluginHooks = pluginHooks;
this.dataSource = dataSource;
this.passwordSecurity = passwordSecurity;
this.management = management;
this.validationService = validationService;
NewAPI.singleton = this;
}
@ -106,7 +108,7 @@ public class NewAPI {
* @see fr.xephi.authme.settings.properties.RestrictionSettings#UNRESTRICTED_NAMES
*/
public boolean isUnrestricted(Player player) {
return Utils.isUnrestricted(player);
return validationService.isUnrestricted(player.getName());
}
/**

21
src/main/java/fr/xephi/authme/datasource/FlatFile.java
View File

@ -6,7 +6,6 @@ import fr.xephi.authme.ConsoleLogger;
import fr.xephi.authme.cache.auth.PlayerAuth;
import fr.xephi.authme.cache.auth.PlayerCache;
import fr.xephi.authme.security.crypts.HashedPassword;
import fr.xephi.authme.settings.Settings;
import java.io.BufferedReader;
import java.io.BufferedWriter;
@ -42,21 +41,11 @@ public class FlatFile implements DataSource {
*/
private final File source;
public FlatFile() {
AuthMe instance = AuthMe.getInstance();
source = new File(instance.getDataFolder(), "auths.db");
try {
source.createNewFile();
} catch (IOException e) {
ConsoleLogger.logException("Cannot open flatfile", e);
if (Settings.isStopEnabled) {
ConsoleLogger.warning("Can't use FLAT FILE... SHUTDOWN...");
instance.getServer().shutdown();
}
if (!Settings.isStopEnabled) {
instance.getServer().getPluginManager().disablePlugin(instance);
}
public FlatFile(AuthMe authMe) throws IOException {
source = new File(authMe.getDataFolder(), "auths.db");
boolean createResult = source.createNewFile();
if (!createResult) {
throw new IOException("Could not create file '" + source.getPath() + "'");
}
}

6
src/main/java/fr/xephi/authme/listener/AuthMePlayerListener.java
View File

@ -13,7 +13,7 @@ import fr.xephi.authme.settings.properties.RegistrationSettings;
import fr.xephi.authme.settings.properties.RestrictionSettings;
import fr.xephi.authme.util.BukkitService;
import fr.xephi.authme.util.TeleportationService;
import fr.xephi.authme.util.Utils;
import fr.xephi.authme.util.ValidationService;
import org.bukkit.Location;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
@ -75,6 +75,8 @@ public class AuthMePlayerListener implements Listener {
private ListenerService listenerService;
@Inject
private TeleportationService teleportationService;
@Inject
private ValidationService validationService;
@EventHandler(ignoreCancelled = true, priority = EventPriority.LOWEST)
public void onPlayerCommandPreprocess(PlayerCommandPreprocessEvent event) {
@ -206,7 +208,7 @@ public class AuthMePlayerListener implements Listener {
@EventHandler(priority = EventPriority.LOWEST)
public void onPlayerLogin(PlayerLoginEvent event) {
final Player player = event.getPlayer();
if (Utils.isUnrestricted(player)) {
if (validationService.isUnrestricted(player.getName())) {
return;
} else if (onJoinVerifier.refusePlayerForFullServer(event)) {
return;

24
src/main/java/fr/xephi/authme/listener/ListenerService.java
View File

@ -6,15 +6,13 @@ import fr.xephi.authme.hooks.PluginHooks;
import fr.xephi.authme.initialization.SettingsDependent;
import fr.xephi.authme.settings.NewSetting;
import fr.xephi.authme.settings.properties.RegistrationSettings;
import fr.xephi.authme.settings.properties.RestrictionSettings;
import fr.xephi.authme.util.ValidationService;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityEvent;
import org.bukkit.event.player.PlayerEvent;
import javax.inject.Inject;
import java.util.HashSet;
import java.util.Set;
/**
* Service class for the AuthMe listeners to determine whether an event should be canceled.
@ -24,15 +22,17 @@ class ListenerService implements SettingsDependent {
private final DataSource dataSource;
private final PluginHooks pluginHooks;
private final PlayerCache playerCache;
private final ValidationService validationService;
private boolean isRegistrationForced;
private Set<String> unrestrictedNames;
@Inject
ListenerService(NewSetting settings, DataSource dataSource, PluginHooks pluginHooks, PlayerCache playerCache) {
ListenerService(NewSetting settings, DataSource dataSource, PluginHooks pluginHooks,
PlayerCache playerCache, ValidationService validationService) {
this.dataSource = dataSource;
this.pluginHooks = pluginHooks;
this.playerCache = playerCache;
this.validationService = validationService;
reload(settings);
}
@ -76,8 +76,6 @@ class ListenerService implements SettingsDependent {
@Override
public void reload(NewSetting settings) {
isRegistrationForced = settings.getProperty(RegistrationSettings.FORCE);
// Keep unrestricted names as Set for more efficient contains()
unrestrictedNames = new HashSet<>(settings.getProperty(RestrictionSettings.UNRESTRICTED_NAMES));
}
/**
@ -88,7 +86,7 @@ class ListenerService implements SettingsDependent {
* @return true if the player may play, false otherwise
*/
private boolean checkAuth(String name) {
if (isUnrestricted(name) || playerCache.isAuthenticated(name)) {
if (validationService.isUnrestricted(name) || playerCache.isAuthenticated(name)) {
return true;
}
if (!isRegistrationForced && !dataSource.isAuthAvailable(name)) {
@ -96,14 +94,4 @@ class ListenerService implements SettingsDependent {
}
return false;
}
/**
* Checks if the name is unrestricted according to the configured settings.
*
* @param name the name to verify
* @return true if unrestricted, false otherwise
*/
private boolean isUnrestricted(String name) {
return unrestrictedNames.contains(name.toLowerCase());
}
}

31
src/main/java/fr/xephi/authme/permission/AuthGroupHandler.java
View File

@ -3,6 +3,7 @@ package fr.xephi.authme.permission;
import fr.xephi.authme.ConsoleLogger;
import fr.xephi.authme.cache.limbo.LimboCache;
import fr.xephi.authme.cache.limbo.PlayerData;
import fr.xephi.authme.initialization.Reloadable;
import fr.xephi.authme.settings.NewSetting;
import fr.xephi.authme.settings.Settings;
import fr.xephi.authme.settings.properties.PluginSettings;
@ -15,7 +16,7 @@ import java.util.Arrays;
/**
* Changes the permission group according to the auth status of the player and the configuration.
*/
public class AuthGroupHandler {
public class AuthGroupHandler implements Reloadable {
@Inject
private PermissionsManager permissionsManager;
@ -26,6 +27,10 @@ public class AuthGroupHandler {
@Inject
private LimboCache limboCache;
private String unloggedInGroup;
private String unregisteredGroup;
private String registeredGroup;
AuthGroupHandler() { }
/**
@ -52,18 +57,18 @@ public class AuthGroupHandler {
switch (group) {
case UNREGISTERED:
// Remove the other group type groups, set the current group
permissionsManager.removeGroups(player, Arrays.asList(Settings.getRegisteredGroup, settings.getProperty(SecuritySettings.UNLOGGEDIN_GROUP)));
return permissionsManager.addGroup(player, Settings.unRegisteredGroup);
permissionsManager.removeGroups(player, Arrays.asList(registeredGroup, unloggedInGroup));
return permissionsManager.addGroup(player, unregisteredGroup);
case REGISTERED:
// Remove the other group type groups, set the current group
permissionsManager.removeGroups(player, Arrays.asList(Settings.unRegisteredGroup, settings.getProperty(SecuritySettings.UNLOGGEDIN_GROUP)));
return permissionsManager.addGroup(player, Settings.getRegisteredGroup);
permissionsManager.removeGroups(player, Arrays.asList(unregisteredGroup, unloggedInGroup));
return permissionsManager.addGroup(player, registeredGroup);
case NOT_LOGGED_IN:
// Remove the other group type groups, set the current group
permissionsManager.removeGroups(player, Arrays.asList(Settings.unRegisteredGroup, Settings.getRegisteredGroup));
return permissionsManager.addGroup(player, settings.getProperty(SecuritySettings.UNLOGGEDIN_GROUP));
permissionsManager.removeGroups(player, Arrays.asList(unregisteredGroup, registeredGroup));
return permissionsManager.addGroup(player, unloggedInGroup);
case LOGGED_IN:
// Get the player data
@ -77,7 +82,7 @@ public class AuthGroupHandler {
// Remove the other group types groups, set the real group
permissionsManager.removeGroups(player,
Arrays.asList(Settings.unRegisteredGroup, Settings.getRegisteredGroup, settings.getProperty(SecuritySettings.UNLOGGEDIN_GROUP))
Arrays.asList(unregisteredGroup, registeredGroup, unloggedInGroup)
);
return permissionsManager.addGroup(player, realGroup);
default:
@ -102,11 +107,17 @@ public class AuthGroupHandler {
}
// Remove old groups
permissionsManager.removeGroups(player, Arrays.asList(Settings.unRegisteredGroup,
Settings.getRegisteredGroup, Settings.getUnloggedinGroup));
permissionsManager.removeGroups(player, Arrays.asList(unregisteredGroup, registeredGroup, unloggedInGroup));
// Add the normal group, return the result
return permissionsManager.addGroup(player, group);
}
@Override
public void reload() {
unloggedInGroup = settings.getProperty(SecuritySettings.UNLOGGEDIN_GROUP);
unregisteredGroup = Settings.unRegisteredGroup;
registeredGroup = Settings.getRegisteredGroup;
}
}

5
src/main/java/fr/xephi/authme/process/login/AsynchronousLogin.java
View File

@ -18,9 +18,9 @@ import fr.xephi.authme.process.AsynchronousProcess;
import fr.xephi.authme.process.ProcessService;
import fr.xephi.authme.process.SyncProcessManager;
import fr.xephi.authme.security.PasswordSecurity;
import fr.xephi.authme.settings.Settings;
import fr.xephi.authme.settings.properties.DatabaseSettings;
import fr.xephi.authme.settings.properties.EmailSettings;
import fr.xephi.authme.settings.properties.HooksSettings;
import fr.xephi.authme.settings.properties.RestrictionSettings;
import fr.xephi.authme.task.PlayerDataTaskManager;
import fr.xephi.authme.util.BukkitService;
@ -94,7 +94,8 @@ public class AsynchronousLogin implements AsynchronousProcess {
return null;
}
if (!service.getProperty(DatabaseSettings.MYSQL_COL_GROUP).isEmpty() && pAuth.getGroupId() == Settings.getNonActivatedGroup) {
if (!service.getProperty(DatabaseSettings.MYSQL_COL_GROUP).isEmpty()
&& pAuth.getGroupId() == service.getProperty(HooksSettings.NON_ACTIVATED_USERS_GROUP)) {
service.send(player, MessageKey.ACCOUNT_NOT_ACTIVATED);
return null;
}

6
src/main/java/fr/xephi/authme/process/quit/AsynchronousQuit.java
View File

@ -12,6 +12,7 @@ import fr.xephi.authme.process.SyncProcessManager;
import fr.xephi.authme.settings.SpawnLoader;
import fr.xephi.authme.settings.properties.RestrictionSettings;
import fr.xephi.authme.util.Utils;
import fr.xephi.authme.util.ValidationService;
import org.bukkit.Location;
import org.bukkit.entity.Player;
@ -40,12 +41,15 @@ public class AsynchronousQuit implements AsynchronousProcess {
@Inject
private SpawnLoader spawnLoader;
@Inject
private ValidationService validationService;
AsynchronousQuit() {
}
public void processQuit(Player player) {
if (player == null || Utils.isUnrestricted(player)) {
if (player == null || validationService.isUnrestricted(player.getName())) {
return;
}
final String name = player.getName().toLowerCase();

35
src/main/java/fr/xephi/authme/settings/Settings.java
View File

@ -1,28 +1,16 @@
package fr.xephi.authme.settings;
import fr.xephi.authme.AuthMe;
import fr.xephi.authme.settings.domain.Property;
import fr.xephi.authme.settings.properties.RestrictionSettings;
import fr.xephi.authme.settings.properties.SecuritySettings;
import org.bukkit.configuration.file.FileConfiguration;
import java.util.List;
/**
* Old settings manager. See {@link NewSetting} for the new manager.
*/
@Deprecated
public final class Settings {
public static List<String> getUnrestrictedName;
public static boolean isAllowRestrictedIp;
public static boolean isStopEnabled;
public static boolean reloadSupport;
public static String getUnloggedinGroup;
public static String unRegisteredGroup;
public static String getRegisteredGroup;
public static int getNonActivatedGroup;
private static FileConfiguration configFile;
/**
* Constructor for Settings.
@ -30,29 +18,8 @@ public final class Settings {
* @param pl AuthMe
*/
public Settings(AuthMe pl) {
configFile = pl.getConfig();
loadVariables();
}
private static void loadVariables() {
isAllowRestrictedIp = load(RestrictionSettings.ENABLE_RESTRICTED_USERS);
getUnloggedinGroup = load(SecuritySettings.UNLOGGEDIN_GROUP);
getNonActivatedGroup = configFile.getInt("ExternalBoardOptions.nonActivedUserGroup", -1);
FileConfiguration configFile = pl.getConfig();
unRegisteredGroup = configFile.getString("GroupOptions.UnregisteredPlayerGroup", "");
getUnrestrictedName = load(RestrictionSettings.UNRESTRICTED_NAMES);
getRegisteredGroup = configFile.getString("GroupOptions.RegisteredPlayerGroup", "");
isStopEnabled = configFile.getBoolean("Security.SQLProblem.stopServer", true);
reloadSupport = configFile.getBoolean("Security.ReloadCommand.useReloadCommandSupport", true);
}
/**
* Load the value via the new Property setup for temporary support within this old settings manager.
*
* @param property The property to load
* @param <T> The property type
* @return The config value of the property
*/
private static <T> T load(Property<T> property) {
return property.getFromFile(configFile);
}
}

9
src/main/java/fr/xephi/authme/util/Utils.java
View File

@ -1,7 +1,6 @@
package fr.xephi.authme.util;
import fr.xephi.authme.ConsoleLogger;
import fr.xephi.authme.settings.Settings;
import org.bukkit.OfflinePlayer;
import org.bukkit.entity.Player;
@ -15,14 +14,6 @@ public final class Utils {
private Utils() {
}
@Deprecated
public static boolean isUnrestricted(Player player) {
// TODO ljacqu 20160602: Checking for Settings.isAllowRestrictedIp is wrong! Nothing in the config suggests
// that this setting has anything to do with unrestricted names
return Settings.isAllowRestrictedIp
&& Settings.getUnrestrictedName.contains(player.getName().toLowerCase());
}
/**
* Get player's UUID if can, name otherwise.
*

15
src/main/java/fr/xephi/authme/util/ValidationService.java
View File

@ -16,7 +16,9 @@ import org.bukkit.command.CommandSender;
import javax.annotation.PostConstruct;
import javax.inject.Inject;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.regex.Pattern;
/**
@ -34,6 +36,7 @@ public class ValidationService implements Reloadable {
private GeoLiteAPI geoLiteApi;
private Pattern passwordRegex;
private Set<String> unrestrictedNames;
ValidationService() { }
@ -41,6 +44,8 @@ public class ValidationService implements Reloadable {
@Override
public void reload() {
passwordRegex = Utils.safePatternCompile(settings.getProperty(RestrictionSettings.ALLOWED_PASSWORD_REGEX));
// Use Set for more efficient contains() lookup
unrestrictedNames = new HashSet<>(settings.getProperty(RestrictionSettings.UNRESTRICTED_NAMES));
}
/**
@ -113,6 +118,16 @@ public class ValidationService implements Reloadable {
ProtectionSettings.COUNTRIES_BLACKLIST);
}
/**
* Checks if the name is unrestricted according to the configured settings.
*
* @param name the name to verify
* @return true if unrestricted, false otherwise
*/
public boolean isUnrestricted(String name) {
return unrestrictedNames.contains(name.toLowerCase());
}
/**
* Verifies whether the given value is allowed according to the given whitelist and blacklist settings.
* Whitelist has precedence over blacklist: if a whitelist is set, the value is rejected if not present

10
src/test/java/fr/xephi/authme/listener/ListenerServiceTest.java
View File

@ -8,7 +8,7 @@ import fr.xephi.authme.datasource.DataSource;
import fr.xephi.authme.hooks.PluginHooks;
import fr.xephi.authme.settings.NewSetting;
import fr.xephi.authme.settings.properties.RegistrationSettings;
import fr.xephi.authme.settings.properties.RestrictionSettings;
import fr.xephi.authme.util.ValidationService;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Player;
import org.bukkit.event.HandlerList;
@ -18,8 +18,6 @@ import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import java.util.Arrays;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;
import static org.mockito.BDDMockito.given;
@ -48,11 +46,12 @@ public class ListenerServiceTest {
@Mock
private PlayerCache playerCache;
@Mock
private ValidationService validationService;
@BeforeInjecting
public void initializeDefaultSettings() {
given(settings.getProperty(RegistrationSettings.FORCE)).willReturn(true);
given(settings.getProperty(RestrictionSettings.UNRESTRICTED_NAMES)).willReturn(
Arrays.asList("npc1", "npc2", "npc3"));
}
@Test
@ -145,6 +144,7 @@ public class ListenerServiceTest {
Player player = mockPlayerWithName(playerName);
EntityEvent event = mock(EntityEvent.class);
given(event.getEntity()).willReturn(player);
given(validationService.isUnrestricted(playerName)).willReturn(true);
// when
boolean result = listenerService.shouldCancelEvent(event);

17
src/test/java/fr/xephi/authme/util/ValidationServiceTest.java
View File

@ -51,6 +51,7 @@ public class ValidationServiceTest {
given(settings.getProperty(SecuritySettings.UNSAFE_PASSWORDS))
.willReturn(Arrays.asList("unsafe", "other-unsafe"));
given(settings.getProperty(EmailSettings.MAX_REG_PER_EMAIL)).willReturn(3);
given(settings.getProperty(RestrictionSettings.UNRESTRICTED_NAMES)).willReturn(Arrays.asList("name01", "npc"));
}
@Test
@ -189,6 +190,7 @@ public class ValidationServiceTest {
assertThat(validationService.validateEmail("your@email.com"), equalTo(false));
}
@Test
public void shouldAllowRegistration() {
// given
CommandSender sender = mock(CommandSender.class);
@ -204,6 +206,7 @@ public class ValidationServiceTest {
assertThat(result, equalTo(true));
}
@Test
public void shouldRejectEmailWithTooManyAccounts() {
// given
CommandSender sender = mock(CommandSender.class);
@ -219,6 +222,7 @@ public class ValidationServiceTest {
assertThat(result, equalTo(false));
}
@Test
public void shouldAllowBypassForPresentPermission() {
// given
CommandSender sender = mock(CommandSender.class);
@ -234,6 +238,19 @@ public class ValidationServiceTest {
assertThat(result, equalTo(true));
}
@Test
public void shouldRecognizeUnrestrictedNames() {
assertThat(validationService.isUnrestricted("npc"), equalTo(true));
assertThat(validationService.isUnrestricted("someplayer"), equalTo(false));
assertThat(validationService.isUnrestricted("NAME01"), equalTo(true));
// Check reloading
given(settings.getProperty(RestrictionSettings.UNRESTRICTED_NAMES)).willReturn(Arrays.asList("new", "names"));
validationService.reload();
assertThat(validationService.isUnrestricted("npc"), equalTo(false));
assertThat(validationService.isUnrestricted("New"), equalTo(true));
}
private static void assertErrorEquals(ValidationResult validationResult, MessageKey messageKey, String... args) {
assertThat(validationResult.hasError(), equalTo(true));
assertThat(validationResult.getMessageKey(), equalTo(messageKey));