Enhance permission checks to support offline users

Author: BenCodez

AdvancedCore/src/main/java/com/bencodez/advancedcore/api/permissions/LuckPermsHandle.java

@@ -2,46 +2,123 @@
 
 import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
 
 import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
 import org.bukkit.plugin.RegisteredServiceProvider;
 
 import com.bencodez.advancedcore.AdvancedCorePlugin;
 
 import lombok.Getter;
 import net.luckperms.api.LuckPerms;
 import net.luckperms.api.model.user.User;
+import net.luckperms.api.query.QueryOptions;
 
 public class LuckPermsHandle {
 	@Getter
-	LuckPerms api = null;
+	private LuckPerms api;
 
+	public void load(AdvancedCorePlugin plugin) {
+		RegisteredServiceProvider<LuckPerms> provider = Bukkit.getServicesManager().getRegistration(LuckPerms.class);
+		if (provider != null) {
+			api = provider.getProvider();
+			plugin.getLogger().info("Loaded LuckPerms hook!");
+		}
+	}
+
+	public boolean luckpermsApiLoaded() {
+		return api != null;
+	}
+
+	/**
+	 * Synchronous permission check.
+	 *
+	 * - If player is online, uses Bukkit (fast). - If player is offline, requires
+	 * LuckPerms User load.
+	 *
+	 * IMPORTANT: This method will NOT block the main thread. If called on the main
+	 * thread for an offline user, it returns false.
+	 */
 	public boolean hasPermission(UUID uuid, String permission) {
+		if (api == null) {
+			return false;
+		}
+
+		// Handle your "!perm" convention
+		boolean negate = permission.startsWith("!");
+		if (negate) {
+			permission = permission.substring(1);
+		}
+
+		// Online fast path (and best context accuracy)
+		Player player = Bukkit.getPlayer(uuid);
+		if (player != null) {
+			boolean has = player.hasPermission(permission);
+			return negate ? !has : has;
+		}
+
+		// Offline: do NOT block main thread
+		if (Bukkit.isPrimaryThread()) {
+			// If you want: plugin.getLogger().fine(...) here, but you don't have plugin in
+			// this class right now.
+			return negate; // treat missing as false, so negation returns true? Usually NOT desired.
+			// I'd recommend: return false; (see note below)
+		}
+
+		// We're async here, safe to wait briefly
 		User user = api.getUserManager().getUser(uuid);
 		if (user == null) {
-			CompletableFuture<User> loadedUser = api.getUserManager().loadUser(uuid);
 			try {
-				user = loadedUser.get(10, TimeUnit.SECONDS);
-			} catch (InterruptedException | ExecutionException | TimeoutException e) {
-				e.printStackTrace();
+				user = api.getUserManager().loadUser(uuid).get(10, TimeUnit.SECONDS);
+			} catch (Exception e) {
 				return false;
 			}
 		}
-		return user.getCachedData().getPermissionData().checkPermission(permission).asBoolean();
+
+		boolean has = checkUserPermission(user, permission, null);
+		return negate ? !has : has;
 	}
 
-	public void load(AdvancedCorePlugin plugin) {
-		RegisteredServiceProvider<LuckPerms> provider = Bukkit.getServicesManager().getRegistration(LuckPerms.class);
-		if (provider != null) {
-			api = provider.getProvider();
-			plugin.getLogger().info("Loaded LuckPerms hook!");
+	/**
+	 * Async permission check for offline users. Safe to call from the main thread.
+	 */
+	public CompletableFuture<Boolean> hasPermissionAsync(UUID uuid, String permission) {
+		if (api == null) {
+			return CompletableFuture.completedFuture(false);
 		}
+
+		boolean negate = permission.startsWith("!");
+		if (negate) {
+			permission = permission.substring(1);
+		}
+
+		// Online fast path
+		Player player = Bukkit.getPlayer(uuid);
+		if (player != null) {
+			boolean has = player.hasPermission(permission);
+			return CompletableFuture.completedFuture(negate ? !has : has);
+		}
+
+		final String permFinal = permission;
+		return api.getUserManager().loadUser(uuid).thenApply(user -> {
+			if (user == null) {
+				return false;
+			}
+			boolean has = checkUserPermission(user, permFinal, null);
+			return negate ? !has : has;
+		});
 	}
 
-	public boolean luckpermsApiLoaded() {
-		return api != null;
+	private boolean checkUserPermission(User user, String permission, Player playerContext) {
+		QueryOptions options;
+
+		if (playerContext != null) {
+			options = api.getContextManager().getQueryOptions(playerContext);
+		} else {
+			options = api.getContextManager().getStaticQueryOptions();
+		}
+
+		return user.getCachedData().getPermissionData(options).checkPermission(permission).asBoolean();
 	}
 }

AdvancedCore/src/main/java/com/bencodez/advancedcore/api/user/AdvancedCoreUser.java

@@ -687,19 +687,31 @@ public boolean hasLoggedOnBefore() {
 	}
 
 	public boolean hasPermission(String perm) {
+		boolean negate = perm != null && perm.startsWith("!");
+		if (negate) {
+			perm = perm.substring(1);
+		}
+
 		Player player = getPlayer();
 		if (!plugin.getOptions().isOnlineMode() && player == null) {
 			player = Bukkit.getPlayer(getPlayerName());
 		}
-		if (player == null) {
-			plugin.debug("Unable to get player for permission check for " + getPlayerName() + "/" + getUUID());
-			return false;
+
+		// Online fast path
+		if (player != null) {
+			boolean has = player.hasPermission(perm);
+			return negate ? !has : has;
 		}
-		if (perm.startsWith("!")) {
-			perm = perm.substring(1);
-			return !player.hasPermission(perm);
+
+		// Offline path: LuckPerms (if available)
+		if (plugin.getLuckPermsHandle() != null && plugin.getLuckPermsHandle().luckpermsApiLoaded()) {
+			boolean has = plugin.getLuckPermsHandle().hasPermission(getJavaUUID(), perm);
+			return negate ? !has : has;
 		}
-		return player.hasPermission(perm);
+
+		plugin.debug("Unable to get player for permission check for " + getPlayerName() + "/" + getUUID()
+				+ " (offline and no LuckPerms hook)");
+		return false;
 	}
 
 	public boolean isBanned() {
@@ -1198,10 +1210,10 @@ public void setUnClaimedChoice(ArrayList<String> rewards) {
 	public void setUserInputMethod(InputMethod method) {
 		setInputMethod(method.toString());
 	}
-	
+
 	@Deprecated
-	public void dontCache() {
-		userDataFetchMode = UserDataFetchMode.NO_CACHE;
+	public void dontCache() {
+		userDataFetchMode = UserDataFetchMode.NO_CACHE;
 	}
 
 	/**