113 lines
3.9 KiB
Java
113 lines
3.9 KiB
Java
package fr.xephi.authme.permission;
|
|
|
|
import fr.xephi.authme.ConsoleLogger;
|
|
import fr.xephi.authme.data.limbo.LimboCache;
|
|
import fr.xephi.authme.data.limbo.LimboPlayer;
|
|
import fr.xephi.authme.initialization.Reloadable;
|
|
import fr.xephi.authme.settings.Settings;
|
|
import fr.xephi.authme.settings.properties.PluginSettings;
|
|
import org.bukkit.entity.Player;
|
|
|
|
import javax.annotation.PostConstruct;
|
|
import javax.inject.Inject;
|
|
import java.util.Optional;
|
|
|
|
/**
|
|
* Changes the permission group according to the auth status of the player and the configuration.
|
|
* <p>
|
|
* If this feature is enabled, the <i>primary permissions group</i> of a player is replaced until he has
|
|
* logged in. Some permission plugins have a notion of a primary group; for other permission plugins the
|
|
* first group is simply taken.
|
|
* <p>
|
|
* The groups that are used as replacement until the player logs in is configurable and depends on if
|
|
* the player is registered or not. Note that some (all?) permission systems require the group to actually
|
|
* exist for the replacement to take place. Furthermore, since some permission groups require that players
|
|
* be in at least one group, this will mean that the player is not removed from his primary group.
|
|
*/
|
|
public class AuthGroupHandler implements Reloadable {
|
|
|
|
@Inject
|
|
private PermissionsManager permissionsManager;
|
|
|
|
@Inject
|
|
private Settings settings;
|
|
|
|
@Inject
|
|
private LimboCache limboCache;
|
|
|
|
private String unregisteredGroup;
|
|
private String registeredGroup;
|
|
|
|
AuthGroupHandler() {
|
|
}
|
|
|
|
/**
|
|
* Sets the group of a player by its authentication status.
|
|
*
|
|
* @param player the player
|
|
* @param groupType the group type
|
|
*/
|
|
public void setGroup(Player player, AuthGroupType groupType) {
|
|
if (!useAuthGroups()) {
|
|
return;
|
|
}
|
|
|
|
String primaryGroup = Optional
|
|
.ofNullable(limboCache.getPlayerData(player.getName()))
|
|
.map(LimboPlayer::getGroup)
|
|
.orElse("");
|
|
|
|
switch (groupType) {
|
|
// Implementation note: some permission systems don't support players not being in any group,
|
|
// so add the new group before removing the old ones
|
|
case UNREGISTERED:
|
|
permissionsManager.addGroup(player, unregisteredGroup);
|
|
permissionsManager.removeGroups(player, registeredGroup, primaryGroup);
|
|
break;
|
|
|
|
case REGISTERED_UNAUTHENTICATED:
|
|
permissionsManager.addGroup(player, registeredGroup);
|
|
permissionsManager.removeGroups(player, unregisteredGroup, primaryGroup);
|
|
break;
|
|
|
|
case LOGGED_IN:
|
|
permissionsManager.addGroup(player, primaryGroup);
|
|
permissionsManager.removeGroups(player, unregisteredGroup, registeredGroup);
|
|
break;
|
|
|
|
default:
|
|
throw new IllegalStateException("Encountered unhandled auth group type '" + groupType + "'");
|
|
}
|
|
|
|
ConsoleLogger.debug(
|
|
() -> player.getName() + " changed to " + groupType + ": has groups " + permissionsManager.getGroups(player));
|
|
}
|
|
|
|
/**
|
|
* Returns whether the auth permissions group function should be used.
|
|
*
|
|
* @return true if should be used, false otherwise
|
|
*/
|
|
private boolean useAuthGroups() {
|
|
// Check whether the permissions check is enabled
|
|
if (!settings.getProperty(PluginSettings.ENABLE_PERMISSION_CHECK)) {
|
|
return false;
|
|
}
|
|
|
|
// Make sure group support is available
|
|
if (!permissionsManager.hasGroupSupport()) {
|
|
ConsoleLogger.warning("The current permissions system doesn't have group support, unable to set group!");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
@PostConstruct
|
|
public void reload() {
|
|
unregisteredGroup = settings.getProperty(PluginSettings.UNREGISTERED_GROUP);
|
|
registeredGroup = settings.getProperty(PluginSettings.REGISTERED_GROUP);
|
|
}
|
|
|
|
}
|