net.luckperms.api.LuckPerms Java Examples

private void setUpForPermissionSystemTest() {
    if (permissionsSystemType == LUCK_PERMS) {
        LuckPerms api = mock(LuckPerms.class);
        ReflectionTestUtils.setField(LuckPermsProvider.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 {
        throw new IllegalStateException("Unhandled permission systems type: " + permissionsSystemType);
    }
}
 

/**
 * Creates a new instance of the event class.
 *
 * @param api an instance of the LuckPerms API
 * @param properties the event properties
 * @return the event instance
 * @throws Throwable if something goes wrong
 */
public LuckPermsEvent newInstance(LuckPerms api, Object... properties) throws Throwable {
    if (properties.length != this.setters.length) {
        throw new IllegalStateException("Unexpected number of properties. given: " + properties.length + ", expected: " + this.setters.length);
    }

    // create a new instance of the event
    final AbstractEvent event = (AbstractEvent) this.constructor.invokeExact(api);

    // set the properties onto the event instance
    for (int i = 0; i < this.setters.length; i++) {
        MethodHandle setter = this.setters[i];
        Object value = properties[i];
        setter.invokeExact(event, value);
    }

    return event;
}
 

public LuckPermsHook() {
    luckPerms = Bukkit.getServicesManager().load(LuckPerms.class);

    // update events
    if (!DiscordSRV.config().getStringList("DisabledPluginHooks").contains("LuckPerms-GroupUpdates")) {
        subscriptions.add(luckPerms.getEventBus().subscribe(UserTrackEvent.class, event -> handle(event.getUser().getUniqueId())));
        subscriptions.add(luckPerms.getEventBus().subscribe(NodeAddEvent.class, event -> handle(event, event.getNode(), true)));
        subscriptions.add(luckPerms.getEventBus().subscribe(NodeRemoveEvent.class, event -> handle(event, event.getNode(), false)));
    }

    // contexts
    if (!DiscordSRV.config().getStringList("DisabledPluginHooks").contains("LuckPerms-Contexts")) {
        luckPerms.getContextManager().registerCalculator(this);
    }
}
 

public static void registerProvider(LuckPerms luckPermsApi) {
    try {
        REGISTER.invoke(null, luckPermsApi);
    } catch (Exception e) {
        e.printStackTrace();
    }
}
 

@Override
protected void registerApiOnPlatform(LuckPerms api) {
    this.bootstrap.getGame().getServiceManager().setProvider(this.bootstrap, LuckPerms.class, api);
}
 

private LuckPermsBridge(LuckPerms api) {
    this.api = api;
}
 

@Override
public @NonNull LuckPerms getLuckPerms() {
    return this.api;
}
 

protected AbstractEvent(LuckPerms api) {
    this.api = api;
}
 

@Override
protected void registerApiOnPlatform(LuckPerms api) {
    // Velocity doesn't have a services manager
}
 

@Override
protected void registerApiOnPlatform(LuckPerms api) {
    this.bootstrap.getServer().getServiceManager().register(LuckPerms.class, api, this.bootstrap, ServicePriority.NORMAL);
}
 

public LuckPermsEventHandler(LuckPerms luckPermsApi) {
    this.luckPermsApi = luckPermsApi;
    this.luckPermsApi.getEventBus().subscribe(GroupDataRecalculateEvent.class, this::onGroupDataRecalculate);
    this.luckPermsApi.getEventBus().subscribe(UserDataRecalculateEvent.class, this::onUserDataRecalculate);
}
 

@Override
protected void registerApiOnPlatform(LuckPerms api) {
    // BungeeCord doesn't have a services manager
}
 

@Override
protected void registerApiOnPlatform(LuckPerms api) {
    this.bootstrap.getServer().getServicesManager().register(LuckPerms.class, api, this.bootstrap, ServicePriority.Normal);
}
 

public HookLuckPerms(NametagHandler handler) {
    this.handler = handler;
    LuckPerms api = LuckPermsProvider.get();
    EventBus eventBus = api.getEventBus();
    eventBus.subscribe(UserDataRecalculateEvent.class, this::onUserDataRecalculateEvent);
}
 

public LuckPerms getApi() {
    return this.luckPermsApi;
}
 

public LuckPermsProvider() {
    final ProviderRegistration<LuckPerms> service = Sponge.getServiceManager().getRegistration(LuckPerms.class).orElse(null);
    this.luckPermsApi = service.getProvider();
}
 

public LuckPermsEventHandler(LuckPerms luckPermsApi) {
    this.luckPermsApi = luckPermsApi;
    this.luckPermsApi.getEventBus().subscribe(GroupDataRecalculateEvent.class, this::onGroupDataRecalculate);
    this.luckPermsApi.getEventBus().subscribe(UserDataRecalculateEvent.class, this::onUserDataRecalculate);
}
 

public LuckPerms getApi() {
    return this.luckPermsApi;
}
 

public LuckPermsProvider() {
    this.luckPermsApi = Bukkit.getServicesManager().getRegistration(LuckPerms.class).getProvider();
    this.luckPermsApi.getContextManager().registerCalculator(new ClaimContextCalculator());
}
 

/**
 * Get the API instance this event was dispatched from
 *
 * @return the api instance
 */
@NonNull LuckPerms getLuckPerms();
 

protected abstract void registerApiOnPlatform(LuckPerms api);