Java LuckPermsApi类代码示例

import me.lucko.luckperms.api.LuckPermsApi; //导入依赖的package包/类
static String getPrefix(ProxiedPlayer p) {
    if (ProxyServer.getInstance().getPluginManager().getPlugin("LuckPerms") == null) {
        return "";
    }
    final LuckPermsApi lpAPI = LuckPerms.getApi();
    User user = lpAPI.getUser(p.getUniqueId());
    Contexts userCtx = lpAPI.getContextForUser(user).orElseThrow(() -> new IllegalStateException("Could not get LuckPerms context for player " + p));
    return user.getCachedData().getMetaData(userCtx).getPrefix();
}
 

import me.lucko.luckperms.api.LuckPermsApi; //导入依赖的package包/类
@Override
protected void execute(Event e) {
	Optional<LuckPermsApi> api = LuckPerms.getApiSafe();
	for (Group g : api.get().getGroups()) {
		if (g.getName().equals(group.getSingle(e))) {
			api.get().getStorage().deleteGroup(g).thenAcceptAsync(wasSuccessful -> {
				if (!wasSuccessful) {
					return;
				}

				api.get().getStorage().loadAllGroups();

			}, api.get().getStorage().getAsyncExecutor());
			break;
		}
	}
}
 

import me.lucko.luckperms.api.LuckPermsApi; //导入依赖的package包/类
private void setUpForPermissionSystemTest() {
    if (permissionsSystemType == LUCK_PERMS) {
        LuckPermsApi api = mock(LuckPermsApi.class);
        ReflectionTestUtils.setField(LuckPerms.class, null, "instance", api);
    } else if (permissionsSystemType == PERMISSIONS_EX) {
        throw new AssumptionViolatedException(
            "PermissionsEx instance cannot be mocked because of missing dependencies -- skipping");
    } else if (permissionsSystemType == Z_PERMISSIONS) {
        ZPermissionsService zPermissionsService = mock(ZPermissionsService.class);
        given(servicesManager.load(ZPermissionsService.class)).willReturn(zPermissionsService);
    } else if (permissionsSystemType == VAULT) {
        setUpForVault();
    } else if (permissionsSystemType != B_PERMISSIONS) {
        throw new IllegalStateException("Unhandled permission systems type: " + permissionsSystemType);
    }
}
 

import me.lucko.luckperms.api.LuckPermsApi; //导入依赖的package包/类
public static void registerProvider(LuckPermsApi luckPermsApi) {
    try {
        REGISTER.invoke(null, luckPermsApi);
    } catch (Exception e) {
        e.printStackTrace();
    }
}
 

import me.lucko.luckperms.api.LuckPermsApi; //导入依赖的package包/类
@Override
public String getGroup(User user) {
	// returns an empty Optional if the APi is not loaded
	Optional<LuckPermsApi> oapi = me.lucko.luckperms.LuckPerms.getApiSafe();
	if(oapi.isPresent()) {
		LuckPermsApi api = oapi.get();
		return api.getGroup(api.getUser(user.getName()).getPrimaryGroup()).getFriendlyName();
	}else {
		return null;
	}
}
 

import me.lucko.luckperms.api.LuckPermsApi; //导入依赖的package包/类
@Override
protected void execute(Event e) {

	Optional<LuckPermsApi> api = LuckPerms.getApiSafe();
	api.get().getStorage().createAndLoadGroup(group.getSingle(e)).thenAcceptAsync(success -> {
		if (!success) {
			return;
		}

		Group Lgroup = api.get().getGroup(group.getSingle(e));
		if (Lgroup == null) {
			return;
		}

		if (perms != null) {
			for (String s : perms.getAll(e)) {
				try {
					Node permission = api.get().buildNode(s).setValue(true).build();
					Lgroup.setPermission(permission);
				} catch (ObjectAlreadyHasException | IllegalArgumentException ex) {
					return;
				}
			}
		}
		api.get().getStorage().saveGroup(Lgroup);
	}, api.get().getStorage().getAsyncExecutor());
}
 

import me.lucko.luckperms.api.LuckPermsApi; //导入依赖的package包/类
@Override
@Nullable
protected String[] get(Event e) {

	ArrayList<String> groups = new ArrayList<>();
	Optional<LuckPermsApi> api = LuckPerms.getApiSafe();
	if (pl.getSingle(e) == null) {
		return new String[groups.size()];
	}
	Consumer<User> action = new Consumer<User>() {
		@Override
		public void accept(User t) {

			for (Group g : api.get().getGroups()) {
				if (t.isInGroup(g)) {
					groups.add(g.getName());
				}
			}
		}

	};

	User user = api.get().getUser(pl.getSingle(e).getUniqueId());
	if (user != null) {
		action.accept(user);

	}
	return groups.toArray(new String[groups.size()]);
}
 

import me.lucko.luckperms.api.LuckPermsApi; //导入依赖的package包/类
@Override
@Nullable
protected String[] get(Event e) {
	Optional<LuckPermsApi> api = LuckPerms.getApiSafe();
	ArrayList<String> groups = new ArrayList<>();

	for (Group g : api.get().getGroups()) {
		groups.add(g.getName());
	}
	return groups.toArray(new String[groups.size()]);

}
 

import me.lucko.luckperms.api.LuckPermsApi; //导入依赖的package包/类
public HookLuckPerms(NametagHandler handler) {
    this.handler = handler;
    LuckPermsApi api = LuckPerms.getApi();
    EventBus eventBus = api.getEventBus();
    eventBus.subscribe(UserDataRecalculateEvent.class, this::onUserDataRecalculateEvent);
}
 

import me.lucko.luckperms.api.LuckPermsApi; //导入依赖的package包/类
@Nonnull
@Override
public LuckPermsApi getApi() {
    return this.api;
}
 

import me.lucko.luckperms.api.LuckPermsApi; //导入依赖的package包/类
public void setApi(LuckPermsApi api) {
    this.api = api;
}
 

import me.lucko.luckperms.api.LuckPermsApi; //导入依赖的package包/类
@Override
protected void execute(Event e) {
	if (offplayer.getSingle(e) == null) {
		return;
	}
	Optional<LuckPermsApi> api = LuckPerms.getApiSafe();
	Consumer<User> action = new Consumer<User>() {
		Node pn = api.get().getNodeFactory().newBuilder(perm.getSingle(e)).setValue(bool.getSingle(e)).build();

		@Override
		public void accept(User t) {
			DataMutateResult result = null;
			if (mark == -1) {
				result = t.setTransientPermissionUnchecked(pn);
			} else {
				result = t.setPermissionUnchecked(pn);
			}
			if (result != DataMutateResult.SUCCESS) {
				return;
			}
			api.get().getStorage().saveUser(t).thenAcceptAsync(wasSuccessful -> {
				if (!wasSuccessful) {
					return;
				}
				t.refreshPermissions();

			}, api.get().getStorage().getAsyncExecutor());
		};

	};
	if (offplayer.getSingle(e).isOnline()) {
		User user = api.get().getUser(offplayer.getSingle(e).getUniqueId());
		if (user != null) {
			action.accept(user);
		}

	} else {
		api.get().getStorage().loadUser(offplayer.getSingle(e).getUniqueId()).thenAcceptAsync(wasSuccessful -> {
			if (!wasSuccessful) {
				return;
			}

			User loadedUser = api.get().getUser(offplayer.getSingle(e).getUniqueId());
			if (loadedUser == null) {
				return;
			}

			action.accept(loadedUser);
			api.get().cleanupUser(loadedUser);
		}, api.get().getStorage().getSyncExecutor());

	}
}
 

import me.lucko.luckperms.api.LuckPermsApi; //导入依赖的package包/类
/**
 * Gets an instance of the {@link LuckPermsApi},
 * throwing {@link IllegalStateException} if an instance is not yet loaded.
 *
 * <p>Will never return null.</p>
 *
 * @return an api instance
 * @throws IllegalStateException if the api is not loaded
 */
@Nonnull
public static LuckPermsApi getApi() {
    if (instance == null) {
        throw new IllegalStateException("API is not loaded.");
    }
    return instance;
}
 

import me.lucko.luckperms.api.LuckPermsApi; //导入依赖的package包/类
/**
 * Get the API instance this event was dispatched from
 *
 * @return the api instance
 */
@Nonnull
LuckPermsApi getApi();
 

import me.lucko.luckperms.api.LuckPermsApi; //导入依赖的package包/类
/**
 * Gets an instance of {@link LuckPermsApi}, if it is loaded.
 *
 * <p>Unlike {@link LuckPerms#getApi}, this method will not throw an
 * {@link IllegalStateException} if an instance is not yet loaded, rather return
 * an empty {@link Optional}.
 *
 * @return an optional api instance
 */
@Nonnull
public static Optional<LuckPermsApi> getApiSafe() {
    return Optional.ofNullable(instance);
}