reupload files

2023-07-11 20:45:01 +08:00
parent b014da245d
commit 7e49e26735
465 changed files with 93823 additions and 0 deletions
@@ -0,0 +1,114 @@
+package fr.xephi.authme.data.limbo;
+
+import fr.xephi.authme.ConsoleLogger;
+import fr.xephi.authme.initialization.Reloadable;
+import fr.xephi.authme.output.ConsoleLoggerFactory;
+import fr.xephi.authme.permission.PermissionsManager;
+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.Collection;
+import java.util.Collections;
+
+/**
+ * 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.
+ */
+class AuthGroupHandler implements Reloadable {
+
+    private final ConsoleLogger logger = ConsoleLoggerFactory.get(AuthGroupHandler.class);
+
+    @Inject
+    private PermissionsManager permissionsManager;
+
+    @Inject
+    private Settings settings;
+
+    private UserGroup unregisteredGroup;
+    private UserGroup registeredGroup;
+
+    AuthGroupHandler() {
+    }
+
+    /**
+     * Sets the group of a player by its authentication status.
+     *
+     * @param player the player
+     * @param limbo the associated limbo player (nullable)
+     * @param groupType the group type
+     */
+    void setGroup(Player player, LimboPlayer limbo, AuthGroupType groupType) {
+        if (!useAuthGroups()) {
+            return;
+        }
+
+        Collection<UserGroup> previousGroups = limbo == null ? Collections.emptyList() : limbo.getGroups();
+
+        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.removeGroup(player, registeredGroup);
+                permissionsManager.removeGroups(player, previousGroups);
+                break;
+
+            case REGISTERED_UNAUTHENTICATED:
+                permissionsManager.addGroup(player, registeredGroup);
+                permissionsManager.removeGroup(player, unregisteredGroup);
+                permissionsManager.removeGroups(player, previousGroups);
+
+                break;
+
+            case LOGGED_IN:
+                permissionsManager.addGroups(player, previousGroups);
+                permissionsManager.removeGroup(player, unregisteredGroup);
+                permissionsManager.removeGroup(player, registeredGroup);
+                break;
+
+            default:
+                throw new IllegalStateException("Encountered unhandled auth group type '" + groupType + "'");
+        }
+
+        logger.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()) {
+            logger.warning("The current permissions system doesn't have group support, unable to set group!");
+            return false;
+        }
+        return true;
+    }
+
+    @Override
+    @PostConstruct
+    public void reload() {
+        unregisteredGroup = new UserGroup(settings.getProperty(PluginSettings.UNREGISTERED_GROUP));
+        registeredGroup = new UserGroup(settings.getProperty(PluginSettings.REGISTERED_GROUP));
+    }
+
+}