Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Luck
|
b3b687d9b7 | ||
|
Luck
|
a413c0a50a | ||
|
Luck
|
1870893fe1 | ||
|
Luck
|
f24562c642 | ||
|
Luck
|
ea358e88e1 | ||
|
Luck
|
cdf8a4ce18 |
No files matched your search
-111
@@ -1,111 +0,0 @@
|
||||
= LuckPerms
|
||||
A (fairly bad) permissions implementation for Bukkit/BungeeCord.
|
||||
|
||||
=== Features
|
||||
* **Group inheritance** - users can be members of multiple groups, groups can inherit other groups
|
||||
* **Multi-server support** - data is synced across all servers/platforms
|
||||
* **Per-server permissions/groups** - define user/group permissions that only apply on certain servers
|
||||
* **Server-specific groups** - define groups that only apply on certain servers
|
||||
* **Tracks / paths** - users can be promoted/demoted along multiple group tracks
|
||||
* **Vault Support** - hooks into Vault to integrate with other plugins
|
||||
* **Easy and simple setup and configuration using commands** - no editing yml files, yuck
|
||||
* **Efficient/lightweight** - maybe? Who knows, it might be.
|
||||
* **BungeeCord compatible** - permissions, users and groups are synced across Bukkit/BungeeCord instances
|
||||
* **Support for MySQL, SQLite & Flatfile (JSON)** - other storage methods coming soon (maybe)
|
||||
|
||||
===== Possible Caveats
|
||||
* Currently only supports MySQL, SQLite & Flatfile (JSON) (support for more methods might come in the future)
|
||||
* Not at all tested and could produce unexpected/buggy results and errors
|
||||
|
||||
=== Setup
|
||||
All configuration options are in the **config.yml** file, which is generated automagically when the plugin first starts.
|
||||
|
||||
You can define the settings for per-server permissions, the storage method and credentials within this file.
|
||||
|
||||
=== Commands
|
||||
|
||||
Command usage is printed to the console/chat whenever invalid arguments are provided. Simply typing /perms will list all commands a user has permission to use.
|
||||
|
||||
==== Aliases
|
||||
| Bukkit | /luckperms |
|
||||
| | /perms |
|
||||
| | /permissions |
|
||||
| | /lp |
|
||||
| | /perm |
|
||||
| Bungee | /luckpermsbungee |
|
||||
| | /bperms |
|
||||
| | /bpermissions |
|
||||
| | /lpb |
|
||||
| | /bperm |
|
||||
|
||||
Arguments: <required> [optional]
|
||||
|
||||
Users with OP have access to all commands.
|
||||
|
||||
Additionally, you can use wildcards to grant users access to a selection of commands.
|
||||
* **All commands** - luckperms.*
|
||||
* **All user commands** - luckperms.user.*
|
||||
* **All group commands** - luckperms.group.*
|
||||
* **All track commands** - luckperms.track.*
|
||||
|
||||
|
||||
| **Command** | **Description** | **Permission** |
|
||||
| /perms | Sends plugin info and usage | N/A |
|
||||
| /perms sync | Runs an update task and reloads the data of all online users | luckperms.sync |
|
||||
| /perms info | Shows information about the plugin | luckperms.info |
|
||||
| /perms debug | Shows some very brief debug info about the number of users/groups loaded | luckperms.debug |
|
||||
| | | |
|
||||
| | | |
|
||||
| | | |
|
||||
| /perms creategroup <group> | Creates a new group with the given name | luckperms.creategroup |
|
||||
| /perms deletegroup <group> | Deletes an existing group | luckperms.deletegroup |
|
||||
| /perms listgroups | Shows a list of the groups registered within the system | luckperms.listgroups |
|
||||
| | | |
|
||||
| | | |
|
||||
| | | |
|
||||
| /perms createtrack <track> | Creates a new track with the given name | luckperms.createtrack |
|
||||
| /perms deletetrack <track> | Deletes an existing track | luckperms.deletetrack |
|
||||
| /perms listtracks | Shows a list of the tracks registered within the system | luckperms.listtracks |
|
||||
| | | |
|
||||
| | | |
|
||||
| | | |
|
||||
| /perms user <user> info | Shows info about the user | luckperms.user.info |
|
||||
| /perms user <user> getuuid | Shows the users Mojang UUID | luckperms.user.getuuid |
|
||||
| /perms user <user> listnodes | Lists all of the permission nodes the user has | luckperms.user.listnodes |
|
||||
| /perms user <user> haspermission <node> [server] | Checks if the user has a permission on a certain server | luckperms.user.haspermission |
|
||||
| /perms user <user> inheritspermission <node> [server] | Checks if the user inherits a permission on a certain server. (This checks all parent groups unlike haspermission) | luckperms.user.inheritspermission |
|
||||
| /perms user <user> set <node> <true/false> [server]| Sets a permission for the user | luckperms.user.setpermission |
|
||||
| /perms user <user> unset <node> [server] | Unsets a permission for the user | luckperms.user.unsetpermission |
|
||||
| /perms user <user> addgroup <group> [server] | Adds the user to a group | luckperms.user.addgroup |
|
||||
| /perms user <user> removegroup <group> [server] | Removes the user from a group | luckperms.user.removegroup |
|
||||
| /perms user <user> setprimarygroup <group> | Sets the users primary group | luckperms.user.setprimarygroup |
|
||||
| /perms user <user> showtracks | Shows a list of the tracks the user can be promoted/demoted on | luckperms.user.showtracks |
|
||||
| /perms user <user> promote <track> | Promotes the user along a given track | luckperms.user.promote |
|
||||
| /perms user <user> demote <track> | Demotes the user along a given track | luckperms.user.demote |
|
||||
| /perms user <user> showpos <track> | Shows the users position on a given track | luckperms.user.showpos |
|
||||
| /perms user <user> clear | Clears all permissions the user has | luckperms.user.clear |
|
||||
| | | |
|
||||
| | | |
|
||||
| | | |
|
||||
| /perms group <group> info | Shows info about the group | luckperms.group.info |
|
||||
| /perms group <group> listnodes | Lists all of the permission nodes the group has | luckperms.group.listnodes |
|
||||
| /perms group <group> haspermission <node> [server] | Checks if the group has a permission on a certain server | luckperms.group.haspermission |
|
||||
| /perms group <group> inheritspermission <node> [server] | Checks if the group inherits a permission on a certain server. (This checks all parent groups unlike haspermission) | luckperms.group.inheritspermission |
|
||||
| /perms group <group> set <node> <true/false> [server]| Sets a permission for the group | luckperms.group.setpermission |
|
||||
| /perms group <group> unset <node> [server] | Unsets a permission for the group | luckperms.group.unsetpermission |
|
||||
| /perms group <group> setinherit <group> [server]| Sets the group to inherit all permissions from another group | luckperms.group.setinherit |
|
||||
| /perms group <group> unsetinherit <group> [server] | Unsets a perviously defined inheritance rule | luckperms.group.unsetinherit |
|
||||
| /perms group <group> showtracks | Shows a list of the tracks that the users in the group can be promoted/demoted on | luckperms.group.showtracks |
|
||||
| /perms group <group> clear | Clears all permissions the group has | luckperms.group.clear |
|
||||
| | | |
|
||||
| | | |
|
||||
| | | |
|
||||
| /perms track <track> info | Shows info about the track | luckperms.track.info |
|
||||
| /perms track <track> append <group> | Appends a group to the end of the track | luckperms.track.append |
|
||||
| /perms track <track> insert <group> <position> | Inserts a group at the given position on the track | luckperms.track.insert |
|
||||
| /perms track <track> remove <group> | Removes a group from the track | luckperms.track.remove |
|
||||
| /perms track <track> clear | Clears all groups on the track | luckperms.track.clear |
|
||||
|
||||
|
||||
=== License
|
||||
See LICENSE.md.
|
||||
@@ -0,0 +1,143 @@
|
||||
# LuckPerms
|
||||
A (fairly bad) permissions implementation for Bukkit/BungeeCord.
|
||||
|
||||
## Features
|
||||
* **Group inheritance** - users can be members of multiple groups, groups can inherit other groups
|
||||
* **Temporary permissions** - users/groups can be given permissions that expire after a given time
|
||||
* **Temporary groups** - users/groups can be added to/inherit other groups temporarily
|
||||
* **Multi-server support** - data is synced across all servers/platforms
|
||||
* **Per-server permissions/groups** - define user/group permissions that only apply on certain servers
|
||||
* **Server-specific groups** - define groups that only apply on certain servers
|
||||
* **Tracks / paths** - users can be promoted/demoted along multiple group tracks
|
||||
* **Vault Support** - hooks into Vault to integrate with other plugins
|
||||
* **Developer API** - easily integrate LuckPerms into your own projects
|
||||
* **Easy and simple setup and configuration using commands** - no editing yml files, yuck
|
||||
* **Efficient/lightweight** - maybe? Who knows, it might be.
|
||||
* **BungeeCord compatible** - permissions, users and groups are synced across Bukkit/BungeeCord instances
|
||||
* **Support for MySQL, SQLite & Flatfile (JSON)** - other storage methods coming soon (maybe)
|
||||
|
||||
##### Possible Caveats
|
||||
* Currently only supports MySQL, SQLite & Flatfile (JSON) (support for more methods might come in the future)
|
||||
* Not at all tested and could produce unexpected/buggy results and errors
|
||||
|
||||
## Setup
|
||||
All configuration options are in the **config.yml** file, which is generated automagically when the plugin first starts.
|
||||
|
||||
You can define the settings for per-server permissions, the storage method and credentials within this file.
|
||||
|
||||
## Info
|
||||
### Permission Calculation
|
||||
Permissions are calculated based on a priority system as follows.
|
||||
|
||||
* Temporary permissions will override non-temporary permissions.
|
||||
|
||||
Example: if a user has a false permission set for "test.node", and a temporary true permission set for "test.node", the temporary permission will override the permanent one, and the user will be granted the true node.
|
||||
|
||||
* Server specific permissions will override generic/global permissions.
|
||||
|
||||
Example: if a user has a global "fly.use" permission, and then has a negated "fly.use" permission on the "factions" server, the server specific permission will override the globally defined one, and the user will be granted the negated node.
|
||||
|
||||
* Inherited permissions will be overridden by an objects own permissions.
|
||||
|
||||
Example: A user is a member of the default group, which grants "some.thing.perm", but the users own permissions has "some.thing.perm" set to false. The inherited permission will be overridden by the users own permissions, and the user will be granted the negative node.
|
||||
|
||||
### Temporary Permissions
|
||||
Temporary permissions are checked each time a user/group is loaded, and when the sync task runs. This means if you set a temporary permission to expire after 30 seconds, it won't actually be removed until the sync task runs.
|
||||
|
||||
The only way around this is to decrease the sync interval.
|
||||
|
||||
## API
|
||||
LuckPerms has an extensive API, allowing for easy integration with other projects. To use the Api, you need to obtain an instance of the `LuckPermsApi` interface. This can be done in two ways, (one way on BungeeCord).
|
||||
|
||||
```java
|
||||
final LuckPermsApi api = LuckPerms.getApi();
|
||||
final LuckPermsApi api = Bukkit.getServicesManager().getRegistration(LuckPermsApi.class).getProvider();
|
||||
```
|
||||
|
||||
If you want to use LuckPerms in your onEnable method, you need to add the following to your plugins `plugin.yml`.
|
||||
```yml
|
||||
depend: [LuckPerms]
|
||||
```
|
||||
All of the available methods can be seen in the various interfaces in the `luckperms-api` module.
|
||||
|
||||
## Commands
|
||||
|
||||
Command usage is printed to the console/chat whenever invalid arguments are provided. Simply typing /perms will list all commands a user has permission to use.
|
||||
|
||||
### Aliases
|
||||
|
||||
| Bukkit | Bungee |
|
||||
|------------------|------------------|
|
||||
| /luckperms | /luckpermsbungee |
|
||||
| /perms | /bperms |
|
||||
| /permissions | /bpermissions |
|
||||
| /lp | /lpb |
|
||||
| /perm | /bperm |
|
||||
|
||||
Arguments: <required> [optional]
|
||||
|
||||
Users with OP have access to all commands.
|
||||
|
||||
Additionally, you can use wildcards to grant users access to a selection of commands.
|
||||
* **All commands** - luckperms.*
|
||||
* **All user commands** - luckperms.user.*
|
||||
* **All group commands** - luckperms.group.*
|
||||
* **All track commands** - luckperms.track.*
|
||||
|
||||
### General
|
||||
* /perms - n/a
|
||||
* /perms sync - luckperms.sync
|
||||
* /perms info - luckperms.info
|
||||
* /perms debug - luckperms.debug
|
||||
* /perms creategroup <group> - luckperms.creategroup
|
||||
* /perms deletegroup <group> - luckperms.deletegroup
|
||||
* /perms listgroups - luckperms.listgroups
|
||||
* /perms createtrack <track> - luckperms.createtrack
|
||||
* /perms deletetrack <track> - luckperms.deletetrack
|
||||
* /perms listtracks - luckperms.listtracks
|
||||
|
||||
### User
|
||||
* /perms user <user> info - luckperms.user.info
|
||||
* /perms user <user> getuuid - luckperms.user.getuuid
|
||||
* /perms user <user> listnodes - luckperms.user.listnodes
|
||||
* /perms user <user> haspermission <node> [server] - luckperms.user.haspermission
|
||||
* /perms user <user> inheritspermission <node> [server] - luckperms.user.inheritspermission
|
||||
* /perms user <user> set <node> <true/false> [server] - luckperms.user.setpermission
|
||||
* /perms user <user> unset <node> [server] - luckperms.user.unsetpermission
|
||||
* /perms user <user> addgroup <group> [server] - luckperms.user.addgroup
|
||||
* /perms user <user> removegroup <group> [server] - luckperms.user.removegroup
|
||||
* /perms user <user> settemp <node> <true/false> <duration> [server] - luckperms.user.settemppermission
|
||||
* /perms user <user> addtempgroup <group> <duration> [server] - luckperms.user.addtempgroup
|
||||
* /perms user <user> removetempgroup <group> [server] - luckperms.user.removetempgroup
|
||||
* /perms user <user> setprimarygroup <group> - luckperms.user.setprimarygroup
|
||||
* /perms user <user> showtracks - luckperms.user.showtracks
|
||||
* /perms user <user> promote <track> - luckperms.user.promote
|
||||
* /perms user <user> demote <track> - luckperms.user.demote
|
||||
* /perms user <user> showpos <track> - luckperms.user.showpos
|
||||
* /perms user <user> clear - luckperms.user.clear
|
||||
|
||||
### Group
|
||||
* /perms group <group> info - luckperms.group.info
|
||||
* /perms group <group> listnodes - luckperms.group.listnodes
|
||||
* /perms group <group> haspermission <node> [server] - luckperms.group.haspermission
|
||||
* /perms group <group> inheritspermission <node> [server] - luckperms.group.inheritspermission
|
||||
* /perms group <group> set <node> <true/false> [server] - luckperms.group.setpermission
|
||||
* /perms group <group> unset <node> [server] - luckperms.group.unsetpermission
|
||||
* /perms group <group> setinherit <group> [server] - luckperms.group.setinherit
|
||||
* /perms group <group> unsetinherit <group> [server] - luckperms.group.unsetinherit
|
||||
* /perms group <group> settemp <node> <true/false> <duration> [server] - settemppermission
|
||||
* /perms group <group> unsettemp <node> [server] - luckperms.group.unsettemppermission
|
||||
* /perms group <group> settempinherit <group> <duration> [server] - luckperms.group.settempinherit
|
||||
* /perms group <group> unsettempinherit <group> [server] - luckperms.group.unsettempinherit
|
||||
* /perms group <group> showtracks - luckperms.group.showtracks
|
||||
* /perms group <group> clear - luckperms.group.clear
|
||||
|
||||
### Track
|
||||
* /perms track <track> info - luckperms.track.info
|
||||
* /perms track <track> append <group> - luckperms.track.append
|
||||
* /perms track <track> insert <group> <position> - luckperms.track.insert
|
||||
* /perms track <track> remove <group> - luckperms.track.remove
|
||||
* /perms track <track> clear - luckperms.track.clear
|
||||
|
||||
## License
|
||||
See LICENSE.md.
|
||||
+26
@@ -0,0 +1,26 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project xmlns="http://maven.apache.org/POM/4.0.0"
|
||||
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
|
||||
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
|
||||
<parent>
|
||||
<artifactId>luckperms</artifactId>
|
||||
<groupId>me.lucko</groupId>
|
||||
<version>1.3</version>
|
||||
</parent>
|
||||
<modelVersion>4.0.0</modelVersion>
|
||||
|
||||
<artifactId>luckperms-api</artifactId>
|
||||
<build>
|
||||
<plugins>
|
||||
<plugin>
|
||||
<groupId>org.apache.maven.plugins</groupId>
|
||||
<artifactId>maven-compiler-plugin</artifactId>
|
||||
<version>3.5.1</version>
|
||||
<configuration>
|
||||
<source>1.8</source>
|
||||
<target>1.8</target>
|
||||
</configuration>
|
||||
</plugin>
|
||||
</plugins>
|
||||
</build>
|
||||
</project>
|
||||
@@ -0,0 +1,30 @@
|
||||
package me.lucko.luckperms;
|
||||
|
||||
import lombok.AccessLevel;
|
||||
import lombok.NoArgsConstructor;
|
||||
import me.lucko.luckperms.api.LuckPermsApi;
|
||||
|
||||
/**
|
||||
* Static access to LuckPerms
|
||||
*/
|
||||
@NoArgsConstructor(access = AccessLevel.PRIVATE)
|
||||
public class LuckPerms {
|
||||
|
||||
private static LuckPermsApi api = null;
|
||||
|
||||
public static LuckPermsApi getApi() {
|
||||
if (api == null) {
|
||||
throw new IllegalStateException("API is not loaded.");
|
||||
}
|
||||
return api;
|
||||
}
|
||||
|
||||
static void registerProvider(LuckPermsApi luckPermsApi) {
|
||||
api = luckPermsApi;
|
||||
}
|
||||
|
||||
static void unregisterProvider() {
|
||||
api = null;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,56 @@
|
||||
package me.lucko.luckperms.api;
|
||||
|
||||
import me.lucko.luckperms.api.data.Callback;
|
||||
|
||||
import java.util.UUID;
|
||||
|
||||
/**
|
||||
* Wrapper interface for the internal Datastore instance
|
||||
* The implementations of this interface limit access to the datastore and add parameter checks to further prevent
|
||||
* errors and ensure all API interactions to not damage the state of the plugin.
|
||||
*/
|
||||
@SuppressWarnings("unused")
|
||||
public interface Datastore {
|
||||
|
||||
String getName();
|
||||
boolean isAcceptingLogins();
|
||||
|
||||
Async async();
|
||||
Sync sync();
|
||||
|
||||
interface Async {
|
||||
void loadOrCreateUser(UUID uuid, String username, Callback callback);
|
||||
void loadUser(UUID uuid, Callback callback);
|
||||
void saveUser(User user, Callback callback);
|
||||
void createAndLoadGroup(String name, Callback callback);
|
||||
void loadGroup(String name, Callback callback);
|
||||
void loadAllGroups(Callback callback);
|
||||
void saveGroup(Group group, Callback callback);
|
||||
void deleteGroup(Group group, Callback callback);
|
||||
void createAndLoadTrack(String name, Callback callback);
|
||||
void loadTrack(String name, Callback callback);
|
||||
void loadAllTracks(Callback callback);
|
||||
void saveTrack(Track track, Callback callback);
|
||||
void deleteTrack(Track track, Callback callback);
|
||||
void saveUUIDData(String username, UUID uuid, Callback callback);
|
||||
void getUUID(String username, Callback.GetUUID callback);
|
||||
}
|
||||
|
||||
interface Sync {
|
||||
boolean loadOrCreateUser(UUID uuid, String username);
|
||||
boolean loadUser(UUID uuid);
|
||||
boolean saveUser(User user);
|
||||
boolean createAndLoadGroup(String name);
|
||||
boolean loadGroup(String name);
|
||||
boolean loadAllGroups();
|
||||
boolean saveGroup(Group group);
|
||||
boolean deleteGroup(Group group);
|
||||
boolean createAndLoadTrack(String name);
|
||||
boolean loadTrack(String name);
|
||||
boolean loadAllTracks();
|
||||
boolean saveTrack(Track track);
|
||||
boolean deleteTrack(Track track);
|
||||
boolean saveUUIDData(String username, UUID uuid);
|
||||
UUID getUUID(String username);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
package me.lucko.luckperms.api;
|
||||
|
||||
/**
|
||||
* Wrapper interface for internal Group instances
|
||||
* The implementations of this interface limit access to the Group and add parameter checks to further prevent
|
||||
* errors and ensure all API interactions to not damage the state of the group.
|
||||
*/
|
||||
@SuppressWarnings("unused")
|
||||
public interface Group extends PermissionObject {
|
||||
|
||||
String getName();
|
||||
|
||||
/**
|
||||
* Clear all of the groups permission nodes
|
||||
*/
|
||||
void clearNodes();
|
||||
|
||||
}
|
||||
@@ -0,0 +1,23 @@
|
||||
package me.lucko.luckperms.api;
|
||||
|
||||
import java.util.UUID;
|
||||
|
||||
@SuppressWarnings("unused")
|
||||
public interface LuckPermsApi {
|
||||
|
||||
void runUpdateTask();
|
||||
String getVersion();
|
||||
|
||||
Datastore getDatastore();
|
||||
|
||||
User getUser(UUID uuid);
|
||||
User getUser(String name);
|
||||
boolean isUserLoaded(UUID uuid);
|
||||
|
||||
Group getGroup(String name);
|
||||
boolean isGroupLoaded(String name);
|
||||
|
||||
Track getTrack(String name);
|
||||
boolean isTrackLoaded(String name);
|
||||
|
||||
}
|
||||
@@ -0,0 +1,166 @@
|
||||
package me.lucko.luckperms.api;
|
||||
|
||||
import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
|
||||
import me.lucko.luckperms.exceptions.ObjectLacksException;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* Wrapper interface for internal PermissionObject (user/group) instances
|
||||
* The implementations of this interface limit access to the object and add parameter checks to further prevent
|
||||
* errors and ensure all API interactions to not damage the state of the object.
|
||||
*/
|
||||
@SuppressWarnings("unused")
|
||||
public interface PermissionObject {
|
||||
|
||||
String getObjectName();
|
||||
|
||||
Map<String, Boolean> getNodes();
|
||||
|
||||
/**
|
||||
* Checks to see if the object has a certain permission
|
||||
* @param node The permission node
|
||||
* @param b If the node is true/false(negated)
|
||||
* @return true if the user has the permission
|
||||
*/
|
||||
boolean hasPermission(String node, boolean b);
|
||||
|
||||
/**
|
||||
* Checks to see the the object has a permission on a certain server
|
||||
* @param node The permission node
|
||||
* @param b If the node is true/false(negated)
|
||||
* @param server The server
|
||||
* @return true if the user has the permission
|
||||
*/
|
||||
boolean hasPermission(String node, boolean b, String server);
|
||||
|
||||
/**
|
||||
* Checks to see the the object has a permission on a certain server
|
||||
* @param node The permission node
|
||||
* @param b If the node is true/false(negated)
|
||||
* @param temporary if the permission is temporary
|
||||
* @return true if the user has the permission
|
||||
*/
|
||||
boolean hasPermission(String node, boolean b, boolean temporary);
|
||||
|
||||
/**
|
||||
* Checks to see if the object inherits a certain permission
|
||||
* @param node The permission node
|
||||
* @param b If the node is true/false(negated)
|
||||
* @return true if the user inherits the permission
|
||||
*/
|
||||
boolean inheritsPermission(String node, boolean b);
|
||||
|
||||
/**
|
||||
* Checks to see the the object inherits a permission on a certain server
|
||||
* @param node The permission node
|
||||
* @param b If the node is true/false(negated)
|
||||
* @param server The server
|
||||
* @return true if the user inherits the permission
|
||||
*/
|
||||
boolean inheritsPermission(String node, boolean b, String server);
|
||||
|
||||
/**
|
||||
* Checks to see if the object inherits a certain permission
|
||||
* @param node The permission node
|
||||
* @param b If the node is true/false(negated)
|
||||
* @param temporary if the permission is temporary
|
||||
* @return true if the user inherits the permission
|
||||
*/
|
||||
boolean inheritsPermission(String node, boolean b, boolean temporary);
|
||||
|
||||
/**
|
||||
* Sets a permission for the object
|
||||
* @param node The node to be set
|
||||
* @param value What to set the node to - true/false(negated)
|
||||
* @throws ObjectAlreadyHasException if the object already has the permission
|
||||
*/
|
||||
void setPermission(String node, boolean value) throws ObjectAlreadyHasException;
|
||||
|
||||
/**
|
||||
* Sets a permission for the object
|
||||
* @param node The node to set
|
||||
* @param value What to set the node to - true/false(negated)
|
||||
* @param server The server to set the permission on
|
||||
* @throws ObjectAlreadyHasException if the object already has the permission
|
||||
*/
|
||||
void setPermission(String node, boolean value, String server) throws ObjectAlreadyHasException;
|
||||
|
||||
/**
|
||||
* Sets a permission for the object
|
||||
* @param node The node to set
|
||||
* @param value What to set the node to - true/false(negated)
|
||||
* @param expireAt The time in unixtime when the permission will expire
|
||||
* @throws ObjectAlreadyHasException if the object already has the permission
|
||||
*/
|
||||
void setPermission(String node, boolean value, long expireAt) throws ObjectAlreadyHasException;
|
||||
|
||||
/**
|
||||
* Sets a permission for the object
|
||||
* @param node The node to set
|
||||
* @param value What to set the node to - true/false(negated)
|
||||
* @param server The server to set the permission on
|
||||
* @param expireAt The time in unixtime when the permission will expire
|
||||
* @throws ObjectAlreadyHasException if the object already has the permission
|
||||
*/
|
||||
void setPermission(String node, boolean value, String server, long expireAt) throws ObjectAlreadyHasException;
|
||||
|
||||
/**
|
||||
* Unsets a permission for the object
|
||||
* @param node The node to be unset
|
||||
* @param temporary if the permission being removed is temporary
|
||||
* @throws ObjectLacksException if the node wasn't already set
|
||||
*/
|
||||
void unsetPermission(String node, boolean temporary) throws ObjectLacksException;
|
||||
|
||||
/**
|
||||
* Unsets a permission for the object
|
||||
* @param node The node to be unset
|
||||
* @throws ObjectLacksException if the node wasn't already set
|
||||
*/
|
||||
void unsetPermission(String node) throws ObjectLacksException;
|
||||
|
||||
/**
|
||||
* Unsets a permission for the object
|
||||
* @param node The node to be unset
|
||||
* @param server The server to unset the node on
|
||||
* @throws ObjectLacksException if the node wasn't already set
|
||||
*/
|
||||
void unsetPermission(String node, String server) throws ObjectLacksException;
|
||||
|
||||
/**
|
||||
* Unsets a permission for the object
|
||||
* @param node The node to be unset
|
||||
* @param server The server to unset the node on
|
||||
* @param temporary if the permission being unset is temporary
|
||||
* @throws ObjectLacksException if the node wasn't already set
|
||||
*/
|
||||
void unsetPermission(String node, String server, boolean temporary) throws ObjectLacksException;
|
||||
|
||||
/**
|
||||
* Gets the permissions and inherited permissions that apply to a specific server
|
||||
* @param server The server to get nodes for (can be null)
|
||||
* @param excludedGroups Groups that shouldn't be inherited, can be null (to prevent circular inheritance issues)
|
||||
* @return a {@link Map} of the permissions
|
||||
*/
|
||||
Map<String, Boolean> getLocalPermissions(String server, List<String> excludedGroups);
|
||||
|
||||
/**
|
||||
* Processes the objects and returns the temporary ones.
|
||||
* @return a map of temporary nodes
|
||||
*/
|
||||
Map<Map.Entry<String, Boolean>, Long> getTemporaryNodes();
|
||||
|
||||
/**
|
||||
* Processes the objects and returns the non-temporary ones.
|
||||
* @return a map of permanent nodes
|
||||
*/
|
||||
Map<String, Boolean> getPermanentNodes();
|
||||
|
||||
/**
|
||||
* Removes temporary permissions that have expired
|
||||
*/
|
||||
void auditTemporaryPermissions();
|
||||
|
||||
}
|
||||
@@ -0,0 +1,95 @@
|
||||
package me.lucko.luckperms.api;
|
||||
|
||||
import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
|
||||
import me.lucko.luckperms.exceptions.ObjectLacksException;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Wrapper interface for internal Track instances
|
||||
* The implementations of this interface limit access to the Track and add parameter checks to further prevent
|
||||
* errors and ensure all API interactions to not damage the state of the track.
|
||||
*/
|
||||
@SuppressWarnings("unused")
|
||||
public interface Track {
|
||||
|
||||
String getName();
|
||||
|
||||
/**
|
||||
* Gets an ordered list of the groups on this track
|
||||
* @return am ordered {@link List} of the groups on this track
|
||||
*/
|
||||
List<String> getGroups();
|
||||
|
||||
/**
|
||||
* Gets the number of groups on this track
|
||||
* @return the number of groups on this track
|
||||
*/
|
||||
int getSize();
|
||||
|
||||
/**
|
||||
* Gets the next group on the track, after the one provided
|
||||
* @param current the group before the group being requested
|
||||
* @return the group name, or null if the end of the track has been reached
|
||||
* @throws ObjectLacksException if the track does not contain the group given
|
||||
*/
|
||||
String getNext(Group current) throws ObjectLacksException;
|
||||
|
||||
/**
|
||||
* Gets the group before the group provided
|
||||
* @param current the group after the group being requested
|
||||
* @return the group name, or null if the start of the track has been reached
|
||||
* @throws ObjectLacksException if the track does not contain the group given
|
||||
*/
|
||||
String getPrevious(Group current) throws ObjectLacksException;
|
||||
|
||||
/**
|
||||
* Appends a group to the end of this track
|
||||
* @param group the group to append
|
||||
* @throws ObjectAlreadyHasException if the group is already on this track somewhere
|
||||
*/
|
||||
void appendGroup(Group group) throws ObjectAlreadyHasException;
|
||||
|
||||
/**
|
||||
* Inserts a group at a certain position on this track
|
||||
* @param group the group to be inserted
|
||||
* @param position the index position (a value of 0 inserts at the start)
|
||||
* @throws ObjectAlreadyHasException if the group is already on this track somewhere
|
||||
* @throws IndexOutOfBoundsException if the position is less than 0 or greater than the size of the track
|
||||
*/
|
||||
void insertGroup(Group group, int position) throws ObjectAlreadyHasException, IndexOutOfBoundsException;
|
||||
|
||||
/**
|
||||
* Removes a group from this track
|
||||
* @param group the group to remove
|
||||
* @throws ObjectLacksException if the group is not on this track
|
||||
*/
|
||||
void removeGroup(Group group) throws ObjectLacksException;
|
||||
|
||||
/**
|
||||
* Removes a group from this track
|
||||
* @param group the group to remove
|
||||
* @throws ObjectLacksException if the group is not on this track
|
||||
*/
|
||||
void removeGroup(String group) throws ObjectLacksException;
|
||||
|
||||
/**
|
||||
* Checks if a group features on this track
|
||||
* @param group the group to check
|
||||
* @return true if the group is on this track
|
||||
*/
|
||||
boolean containsGroup(Group group);
|
||||
|
||||
/**
|
||||
* Checks if a group features on this track
|
||||
* @param group the group to check
|
||||
* @return true if the group is on this track
|
||||
*/
|
||||
boolean containsGroup(String group);
|
||||
|
||||
/**
|
||||
* Clear all of the groups within this track
|
||||
*/
|
||||
void clearGroups();
|
||||
|
||||
}
|
||||
@@ -0,0 +1,120 @@
|
||||
package me.lucko.luckperms.api;
|
||||
|
||||
import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
|
||||
import me.lucko.luckperms.exceptions.ObjectLacksException;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.UUID;
|
||||
|
||||
/**
|
||||
* Wrapper interface for internal User instances
|
||||
* The implementations of this interface limit access to the User and add parameter checks to further prevent
|
||||
* errors and ensure all API interactions to not damage the state of the user.
|
||||
*/
|
||||
@SuppressWarnings("unused")
|
||||
public interface User extends PermissionObject {
|
||||
|
||||
UUID getUuid();
|
||||
String getName();
|
||||
String getPrimaryGroup();
|
||||
void setPrimaryGroup(String s) throws ObjectAlreadyHasException;
|
||||
void refreshPermissions();
|
||||
|
||||
/**
|
||||
* Check to see if the user is a member of a group
|
||||
* @param group The group to check membership of
|
||||
* @return true if the user is a member of the group
|
||||
*/
|
||||
boolean isInGroup(Group group);
|
||||
|
||||
/**
|
||||
* Check to see if a user is a member of a group on a specific server
|
||||
* @param group The group to check membership of
|
||||
* @param server The server to check on
|
||||
* @return true if the user is a member of the group
|
||||
*/
|
||||
boolean isInGroup(Group group, String server);
|
||||
|
||||
/**
|
||||
* Add a user to a group
|
||||
* @param group The group to add the user to
|
||||
* @throws ObjectAlreadyHasException if the user is already a member of the group
|
||||
*/
|
||||
void addGroup(Group group) throws ObjectAlreadyHasException;
|
||||
|
||||
/**
|
||||
* Add a user to a group on a specific server
|
||||
* @param group The group to add the user to
|
||||
* @param server The server to add the group on
|
||||
* @throws ObjectAlreadyHasException if the user is already a member of the group on that server
|
||||
*/
|
||||
void addGroup(Group group, String server) throws ObjectAlreadyHasException;
|
||||
|
||||
/**
|
||||
* Add a user to a group on a specific server
|
||||
* @param group The group to add the user to
|
||||
* @param expireAt when the group should expire
|
||||
* @throws ObjectAlreadyHasException if the user is already a member of the group on that server
|
||||
*/
|
||||
void addGroup(Group group, long expireAt) throws ObjectAlreadyHasException;
|
||||
|
||||
/**
|
||||
* Add a user to a group on a specific server
|
||||
* @param group The group to add the user to
|
||||
* @param server The server to add the group on
|
||||
* @param expireAt when the group should expire
|
||||
* @throws ObjectAlreadyHasException if the user is already a member of the group on that server
|
||||
*/
|
||||
void addGroup(Group group, String server, long expireAt) throws ObjectAlreadyHasException;
|
||||
|
||||
/**
|
||||
* Remove the user from a group
|
||||
* @param group the group to remove the user from
|
||||
* @throws ObjectLacksException if the user isn't a member of the group
|
||||
*/
|
||||
void removeGroup(Group group) throws ObjectLacksException;
|
||||
|
||||
/**
|
||||
* Remove the user from a group
|
||||
* @param group the group to remove the user from
|
||||
* @param temporary if the group being removed is temporary
|
||||
* @throws ObjectLacksException if the user isn't a member of the group
|
||||
*/
|
||||
void removeGroup(Group group, boolean temporary) throws ObjectLacksException;
|
||||
|
||||
/**
|
||||
* Remove the user from a group
|
||||
* @param group The group to remove the user from
|
||||
* @param server The server to remove the group on
|
||||
* @throws ObjectLacksException if the user isn't a member of the group
|
||||
*/
|
||||
void removeGroup(Group group, String server) throws ObjectLacksException;
|
||||
|
||||
/**
|
||||
* Remove the user from a group
|
||||
* @param group The group to remove the user from
|
||||
* @param server The server to remove the group on
|
||||
* @param temporary if the group being removed is temporary
|
||||
* @throws ObjectLacksException if the user isn't a member of the group
|
||||
*/
|
||||
void removeGroup(Group group, String server, boolean temporary) throws ObjectLacksException;
|
||||
|
||||
/**
|
||||
* Clear all of the users permission nodes
|
||||
*/
|
||||
void clearNodes();
|
||||
|
||||
/**
|
||||
* Get a {@link List} of all of the groups the user is a member of, on all servers
|
||||
* @return a {@link List} of group names
|
||||
*/
|
||||
List<String> getGroupNames();
|
||||
|
||||
/**
|
||||
* Get a {@link List} of the groups the user is a member of on a specific server
|
||||
* @param server the server to check
|
||||
* @return a {@link List} of group names
|
||||
*/
|
||||
List<String> getLocalGroups(String server);
|
||||
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
package me.lucko.luckperms.api.data;
|
||||
|
||||
import java.util.UUID;
|
||||
|
||||
public interface Callback {
|
||||
void onComplete(boolean success);
|
||||
|
||||
interface GetUUID {
|
||||
void onComplete(UUID uuid);
|
||||
}
|
||||
}
|
||||
File renamed without changes.
File renamed without changes.
+9
-2
@@ -5,12 +5,12 @@
|
||||
<parent>
|
||||
<artifactId>luckperms</artifactId>
|
||||
<groupId>me.lucko</groupId>
|
||||
<version>1.1</version>
|
||||
<version>1.3</version>
|
||||
</parent>
|
||||
<modelVersion>4.0.0</modelVersion>
|
||||
|
||||
<artifactId>luckperms-bukkit</artifactId>
|
||||
<version>1.0-SNAPSHOT</version>
|
||||
<version>$(project.parent.version)</version>
|
||||
<packaging>jar</packaging>
|
||||
<name>LuckPerms</name>
|
||||
|
||||
@@ -75,5 +75,12 @@
|
||||
<version>${project.parent.version}</version>
|
||||
<scope>compile</scope>
|
||||
</dependency>
|
||||
<!-- LuckPerms API -->
|
||||
<dependency>
|
||||
<groupId>me.lucko</groupId>
|
||||
<artifactId>luckperms-api</artifactId>
|
||||
<version>${project.parent.version}</version>
|
||||
<scope>compile</scope>
|
||||
</dependency>
|
||||
</dependencies>
|
||||
</project>
|
||||
@@ -7,66 +7,49 @@ import org.bukkit.configuration.file.YamlConfiguration;
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
|
||||
public class BukkitConfig implements LPConfiguration {
|
||||
private final LPBukkitPlugin plugin;
|
||||
class BukkitConfig extends LPConfiguration<LPBukkitPlugin> {
|
||||
private YamlConfiguration configuration;
|
||||
|
||||
public BukkitConfig(LPBukkitPlugin plugin) {
|
||||
this.plugin = plugin;
|
||||
create();
|
||||
BukkitConfig(LPBukkitPlugin plugin) {
|
||||
super(plugin, "global", true, "sqlite");
|
||||
}
|
||||
|
||||
@SuppressWarnings("ResultOfMethodCallIgnored")
|
||||
private void create() {
|
||||
File configFile = new File(plugin.getDataFolder(), "config.yml");
|
||||
@Override
|
||||
protected void init() {
|
||||
File configFile = new File(getPlugin().getDataFolder(), "config.yml");
|
||||
|
||||
if (!configFile.exists()) {
|
||||
configFile.getParentFile().mkdirs();
|
||||
plugin.saveResource("config.yml", false);
|
||||
getPlugin().saveResource("config.yml", false);
|
||||
}
|
||||
|
||||
configuration = new YamlConfiguration();
|
||||
|
||||
try {
|
||||
configuration.load(configFile);
|
||||
|
||||
} catch (InvalidConfigurationException | IOException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getServer() {
|
||||
return configuration.getString("server", "global");
|
||||
protected void set(String path, Object value) {
|
||||
configuration.set(path, value);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getSyncTime() {
|
||||
return configuration.getInt("sql.sync-minutes", 3);
|
||||
protected String getString(String path, String def) {
|
||||
return configuration.getString(path, def);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getDefaultGroupNode() {
|
||||
return "group." + configuration.getString("default-group", "default");
|
||||
protected int getInt(String path, int def) {
|
||||
return configuration.getInt(path, def);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getDefaultGroupName() {
|
||||
return configuration.getString("default-group", "default");
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean getIncludeGlobalPerms() {
|
||||
return configuration.getBoolean("include-global", true);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getDatabaseValue(String value) {
|
||||
return configuration.getString("sql." + value);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getStorageMethod() {
|
||||
return configuration.getString("storage-method", "sqlite");
|
||||
protected boolean getBoolean(String path, boolean def) {
|
||||
return configuration.getBoolean(path, def);
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,8 @@
|
||||
package me.lucko.luckperms;
|
||||
|
||||
import lombok.Getter;
|
||||
import me.lucko.luckperms.api.LuckPermsApi;
|
||||
import me.lucko.luckperms.api.implementation.ApiProvider;
|
||||
import me.lucko.luckperms.data.Datastore;
|
||||
import me.lucko.luckperms.data.MySQLConfiguration;
|
||||
import me.lucko.luckperms.data.methods.FlatfileDatastore;
|
||||
@@ -18,6 +20,7 @@ import org.bukkit.Bukkit;
|
||||
import org.bukkit.command.PluginCommand;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.plugin.PluginManager;
|
||||
import org.bukkit.plugin.ServicePriority;
|
||||
import org.bukkit.plugin.java.JavaPlugin;
|
||||
|
||||
import java.io.File;
|
||||
@@ -28,7 +31,7 @@ import java.util.stream.Collectors;
|
||||
|
||||
@Getter
|
||||
public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
|
||||
public static final String VERSION = "v1.1";
|
||||
public static final String VERSION = "v1.3";
|
||||
|
||||
private LPConfiguration configuration;
|
||||
private UserManager userManager;
|
||||
@@ -38,6 +41,7 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
|
||||
|
||||
@Override
|
||||
public void onEnable() {
|
||||
getLogger().info("Loading configuration...");
|
||||
configuration = new BukkitConfig(this);
|
||||
|
||||
// register events
|
||||
@@ -45,14 +49,15 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
|
||||
pm.registerEvents(new PlayerListener(this), this);
|
||||
|
||||
// register commands
|
||||
getLogger().info("Registering commands...");
|
||||
CommandManagerBukkit commandManager = new CommandManagerBukkit(this);
|
||||
PluginCommand main = getServer().getPluginCommand("luckperms");
|
||||
main.setExecutor(commandManager);
|
||||
main.setTabCompleter(commandManager);
|
||||
main.setAliases(Arrays.asList("perms", "lp", "permissions", "p", "perm"));
|
||||
|
||||
getLogger().info("Detecting storage method...");
|
||||
final String storageMethod = configuration.getStorageMethod();
|
||||
|
||||
if (storageMethod.equalsIgnoreCase("mysql")) {
|
||||
getLogger().info("Using MySQL as storage method.");
|
||||
datastore = new MySQLDatastore(this, new MySQLConfiguration(
|
||||
@@ -68,18 +73,25 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
|
||||
getLogger().info("Using Flatfile (JSON) as storage method.");
|
||||
datastore = new FlatfileDatastore(this, getDataFolder());
|
||||
} else {
|
||||
getLogger().warning("Storage method '" + storageMethod + "' was not recognised. Using SQLite as fallback.");
|
||||
getLogger().severe("Storage method '" + storageMethod + "' was not recognised. Using SQLite as fallback.");
|
||||
datastore = new SQLiteDatastore(this, new File(getDataFolder(), "luckperms.sqlite"));
|
||||
}
|
||||
|
||||
getLogger().info("Initialising datastore...");
|
||||
datastore.init();
|
||||
|
||||
getLogger().info("Loading internal permission managers...");
|
||||
userManager = new BukkitUserManager(this);
|
||||
groupManager = new GroupManager(this);
|
||||
trackManager = new TrackManager(this);
|
||||
trackManager = new TrackManager();
|
||||
|
||||
// Run update task to refresh any online users
|
||||
runUpdateTask();
|
||||
getLogger().info("Scheduling Update Task to refresh any online users.");
|
||||
try {
|
||||
new UpdateTask(this).run();
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
|
||||
int mins = getConfiguration().getSyncTime();
|
||||
if (mins > 0) {
|
||||
@@ -88,18 +100,35 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
|
||||
}
|
||||
|
||||
// Provide vault support
|
||||
if (getServer().getPluginManager().isPluginEnabled("Vault")) {
|
||||
VaultHook.hook(this);
|
||||
getLogger().info("Registered Vault permission & chat hook.");
|
||||
} else {
|
||||
getLogger().info("Vault not found.");
|
||||
getLogger().info("Attempting to hook into Vault...");
|
||||
try {
|
||||
if (getServer().getPluginManager().isPluginEnabled("Vault")) {
|
||||
VaultHook.hook(this);
|
||||
getLogger().info("Registered Vault permission & chat hook.");
|
||||
} else {
|
||||
getLogger().info("Vault not found.");
|
||||
}
|
||||
} catch (Exception e) {
|
||||
getLogger().severe("Error occurred whilst hooking into Vault.");
|
||||
e.printStackTrace();
|
||||
}
|
||||
|
||||
getLogger().info("Registering API...");
|
||||
final ApiProvider provider = new ApiProvider(this);
|
||||
LuckPerms.registerProvider(provider);
|
||||
getServer().getServicesManager().register(LuckPermsApi.class, provider, this, ServicePriority.Normal);
|
||||
|
||||
getLogger().info("Successfully loaded.");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onDisable() {
|
||||
getLogger().info("Closing datastore...");
|
||||
datastore.shutdown();
|
||||
|
||||
getLogger().info("Unregistering API...");
|
||||
LuckPerms.unregisterProvider();
|
||||
getServer().getServicesManager().unregisterAll(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
|
||||
@@ -16,13 +16,14 @@ import org.bukkit.event.player.PlayerQuitEvent;
|
||||
|
||||
@AllArgsConstructor
|
||||
public class PlayerListener implements Listener {
|
||||
private static final String KICK_MESSAGE = Util.color(Message.PREFIX + "User data could not be loaded. Please contact an administrator.");
|
||||
private final LPBukkitPlugin plugin;
|
||||
|
||||
@EventHandler
|
||||
public void onPlayerPreLogin(AsyncPlayerPreLoginEvent e) {
|
||||
if (!plugin.getDatastore().isAcceptingLogins()) {
|
||||
e.disallow(AsyncPlayerPreLoginEvent.Result.KICK_OTHER,
|
||||
Util.color(Message.PREFIX + "Error whilst validating login with the network. \nPlease contact an administrator."));
|
||||
// Datastore is disabled, prevent players from joining the server
|
||||
e.disallow(AsyncPlayerPreLoginEvent.Result.KICK_OTHER, KICK_MESSAGE);
|
||||
return;
|
||||
}
|
||||
plugin.getDatastore().loadOrCreateUser(e.getUniqueId(), e.getName());
|
||||
@@ -30,12 +31,11 @@ public class PlayerListener implements Listener {
|
||||
|
||||
@EventHandler
|
||||
public void onPlayerLogin(PlayerLoginEvent e) {
|
||||
Player player = e.getPlayer();
|
||||
User user = plugin.getUserManager().getUser(player.getUniqueId());
|
||||
final Player player = e.getPlayer();
|
||||
final User user = plugin.getUserManager().getUser(player.getUniqueId());
|
||||
|
||||
if (user == null) {
|
||||
e.disallow(PlayerLoginEvent.Result.KICK_OTHER,
|
||||
Util.color(Message.PREFIX + "User data could not be loaded. Please contact an administrator."));
|
||||
e.disallow(PlayerLoginEvent.Result.KICK_OTHER, KICK_MESSAGE);
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -52,7 +52,7 @@ public class PlayerListener implements Listener {
|
||||
// Save UUID data for the player
|
||||
plugin.getDatastore().saveUUIDData(e.getPlayer().getName(), e.getPlayer().getUniqueId(), success -> {});
|
||||
|
||||
User user = plugin.getUserManager().getUser(e.getPlayer().getUniqueId());
|
||||
final User user = plugin.getUserManager().getUser(e.getPlayer().getUniqueId());
|
||||
if (user != null) {
|
||||
// Refresh permissions again
|
||||
user.refreshPermissions();
|
||||
@@ -62,10 +62,10 @@ public class PlayerListener implements Listener {
|
||||
|
||||
@EventHandler
|
||||
public void onPlayerQuit(PlayerQuitEvent e) {
|
||||
Player player = e.getPlayer();
|
||||
final Player player = e.getPlayer();
|
||||
|
||||
// Unload the user from memory when they disconnect
|
||||
User user = plugin.getUserManager().getUser(player.getUniqueId());
|
||||
final User user = plugin.getUserManager().getUser(player.getUniqueId());
|
||||
plugin.getUserManager().unloadUser(user);
|
||||
}
|
||||
|
||||
|
||||
@@ -3,7 +3,6 @@ package me.lucko.luckperms.users;
|
||||
import lombok.Getter;
|
||||
import lombok.Setter;
|
||||
import me.lucko.luckperms.LPBukkitPlugin;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.permissions.PermissionAttachment;
|
||||
|
||||
@@ -31,7 +30,7 @@ public class BukkitUser extends User {
|
||||
@Override
|
||||
public void refreshPermissions() {
|
||||
plugin.doSync(() -> {
|
||||
Player player = Bukkit.getPlayer(getUuid());
|
||||
final Player player = plugin.getServer().getPlayer(getUuid());
|
||||
if (player == null) return;
|
||||
|
||||
if (attachment == null) {
|
||||
|
||||
@@ -1,7 +1,6 @@
|
||||
package me.lucko.luckperms.users;
|
||||
|
||||
import me.lucko.luckperms.LPBukkitPlugin;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.entity.Player;
|
||||
|
||||
import java.util.UUID;
|
||||
@@ -22,7 +21,7 @@ public class BukkitUserManager extends UserManager {
|
||||
BukkitUser u = (BukkitUser) user;
|
||||
|
||||
if (u.getAttachment() != null) {
|
||||
Player player = Bukkit.getPlayer(u.getUuid());
|
||||
Player player = plugin.getServer().getPlayer(u.getUuid());
|
||||
|
||||
if (player != null) {
|
||||
player.removeAttachment(u.getAttachment());
|
||||
@@ -37,7 +36,7 @@ public class BukkitUserManager extends UserManager {
|
||||
|
||||
@Override
|
||||
public void cleanupUser(User user) {
|
||||
if (Bukkit.getPlayer(user.getUuid()) == null) {
|
||||
if (plugin.getServer().getPlayer(user.getUuid()) == null) {
|
||||
unloadUser(user);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
name: LuckPerms
|
||||
author: Luck
|
||||
version: 1.1
|
||||
version: 1.2
|
||||
main: me.lucko.luckperms.LPBukkitPlugin
|
||||
softdepend: [Vault]
|
||||
description: A permissions plugin
|
||||
|
||||
+9
-2
@@ -5,12 +5,12 @@
|
||||
<parent>
|
||||
<artifactId>luckperms</artifactId>
|
||||
<groupId>me.lucko</groupId>
|
||||
<version>1.1</version>
|
||||
<version>1.3</version>
|
||||
</parent>
|
||||
<modelVersion>4.0.0</modelVersion>
|
||||
|
||||
<artifactId>luckperms-bungee</artifactId>
|
||||
<version>1.0-SNAPSHOT</version>
|
||||
<version>$(project.parent.version)</version>
|
||||
<packaging>jar</packaging>
|
||||
<name>LuckPerms</name>
|
||||
|
||||
@@ -68,6 +68,13 @@
|
||||
<version>${project.parent.version}</version>
|
||||
<scope>compile</scope>
|
||||
</dependency>
|
||||
<!-- LuckPerms API -->
|
||||
<dependency>
|
||||
<groupId>me.lucko</groupId>
|
||||
<artifactId>luckperms-api</artifactId>
|
||||
<version>${project.parent.version}</version>
|
||||
<scope>compile</scope>
|
||||
</dependency>
|
||||
</dependencies>
|
||||
|
||||
</project>
|
||||
@@ -10,30 +10,20 @@ import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.nio.file.Files;
|
||||
|
||||
public class BungeeConfig implements LPConfiguration {
|
||||
private final LPBungeePlugin plugin;
|
||||
class BungeeConfig extends LPConfiguration<LPBungeePlugin> {
|
||||
private Configuration configuration;
|
||||
|
||||
public BungeeConfig(LPBungeePlugin plugin) {
|
||||
this.plugin = plugin;
|
||||
reload();
|
||||
}
|
||||
|
||||
private void reload() {
|
||||
try {
|
||||
configuration = ConfigurationProvider.getProvider(YamlConfiguration.class).load(makeFile("config.yml"));
|
||||
} catch (IOException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
BungeeConfig(LPBungeePlugin plugin) {
|
||||
super(plugin, "bungee", false, "flatfile");
|
||||
}
|
||||
|
||||
@SuppressWarnings("ResultOfMethodCallIgnored")
|
||||
private File makeFile(String file) throws IOException {
|
||||
File cfg = new File(plugin.getDataFolder(), file);
|
||||
File cfg = new File(getPlugin().getDataFolder(), file);
|
||||
|
||||
if (!cfg.exists()) {
|
||||
plugin.getDataFolder().mkdir();
|
||||
try (InputStream is = plugin.getResourceAsStream(file)) {
|
||||
getPlugin().getDataFolder().mkdir();
|
||||
try (InputStream is = getPlugin().getResourceAsStream(file)) {
|
||||
Files.copy(is, cfg.toPath());
|
||||
}
|
||||
}
|
||||
@@ -42,37 +32,31 @@ public class BungeeConfig implements LPConfiguration {
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getServer() {
|
||||
return configuration.getString("server", "bungee");
|
||||
protected void init() {
|
||||
try {
|
||||
configuration = ConfigurationProvider.getProvider(YamlConfiguration.class).load(makeFile("config.yml"));
|
||||
} catch (IOException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getSyncTime() {
|
||||
return configuration.getInt("sql.sync-minutes", 3);
|
||||
protected void set(String path, Object value) {
|
||||
configuration.set(path, value);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getDefaultGroupNode() {
|
||||
return "group." + configuration.getString("default-group", "default");
|
||||
protected String getString(String path, String def) {
|
||||
return configuration.getString(path, def);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getDefaultGroupName() {
|
||||
return configuration.getString("default-group", "default");
|
||||
protected int getInt(String path, int def) {
|
||||
return configuration.getInt(path, def);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean getIncludeGlobalPerms() {
|
||||
return configuration.getBoolean("include-global", false);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getDatabaseValue(String value) {
|
||||
return configuration.getString("sql." + value);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getStorageMethod() {
|
||||
return configuration.getString("storage-method", "sqlite");
|
||||
protected boolean getBoolean(String path, boolean def) {
|
||||
return configuration.getBoolean(path, def);
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,7 @@
|
||||
package me.lucko.luckperms;
|
||||
|
||||
import lombok.Getter;
|
||||
import me.lucko.luckperms.api.implementation.ApiProvider;
|
||||
import me.lucko.luckperms.commands.CommandManager;
|
||||
import me.lucko.luckperms.data.Datastore;
|
||||
import me.lucko.luckperms.data.MySQLConfiguration;
|
||||
@@ -23,7 +24,7 @@ import java.util.stream.Collectors;
|
||||
|
||||
@Getter
|
||||
public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
|
||||
public static final String VERSION = "v1.1";
|
||||
public static final String VERSION = "v1.3";
|
||||
|
||||
private LPConfiguration configuration;
|
||||
private UserManager userManager;
|
||||
@@ -33,19 +34,21 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
|
||||
|
||||
@Override
|
||||
public void onEnable() {
|
||||
getLogger().info("Loading configuration...");
|
||||
configuration = new BungeeConfig(this);
|
||||
|
||||
// register events
|
||||
getProxy().getPluginManager().registerListener(this, new PlayerListener(this));
|
||||
|
||||
// register commands
|
||||
getLogger().info("Registering commands...");
|
||||
getProxy().getPluginManager().registerCommand(this, new MainCommand(new CommandManager(this)));
|
||||
|
||||
// disable the default Bungee /perms command so it gets handled by the Bukkit plugin
|
||||
getProxy().getDisabledCommands().add("perms");
|
||||
|
||||
getLogger().info("Detecting storage method...");
|
||||
final String storageMethod = configuration.getStorageMethod();
|
||||
|
||||
if (storageMethod.equalsIgnoreCase("mysql")) {
|
||||
getLogger().info("Using MySQL as storage method.");
|
||||
datastore = new MySQLDatastore(this, new MySQLConfiguration(
|
||||
@@ -58,25 +61,44 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
|
||||
getLogger().info("Using Flatfile (JSON) as storage method.");
|
||||
datastore = new FlatfileDatastore(this, getDataFolder());
|
||||
} else {
|
||||
getLogger().warning("Storage method '" + storageMethod + "' was not recognised. Using Flatfile as fallback.");
|
||||
getLogger().severe("Storage method '" + storageMethod + "' was not recognised. Using Flatfile as fallback.");
|
||||
datastore = new FlatfileDatastore(this, getDataFolder());
|
||||
}
|
||||
|
||||
getLogger().info("Initialising datastore...");
|
||||
datastore.init();
|
||||
|
||||
getLogger().info("Loading internal permission managers...");
|
||||
userManager = new BungeeUserManager(this);
|
||||
groupManager = new GroupManager(this);
|
||||
trackManager = new TrackManager(this);
|
||||
trackManager = new TrackManager();
|
||||
|
||||
// Run update task to refresh any online users
|
||||
getLogger().info("Scheduling Update Task to refresh any online users.");
|
||||
try {
|
||||
new UpdateTask(this).run();
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
|
||||
int mins = getConfiguration().getSyncTime();
|
||||
if (mins > 0) {
|
||||
getProxy().getScheduler().schedule(this, new UpdateTask(this), mins, mins, TimeUnit.MINUTES);
|
||||
}
|
||||
|
||||
getLogger().info("Registering API...");
|
||||
LuckPerms.registerProvider(new ApiProvider(this));
|
||||
|
||||
getLogger().info("Successfully loaded.");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onDisable() {
|
||||
getLogger().info("Closing datastore...");
|
||||
datastore.shutdown();
|
||||
|
||||
getLogger().info("Unregistering API...");
|
||||
LuckPerms.unregisterProvider();
|
||||
}
|
||||
|
||||
@Override
|
||||
|
||||
@@ -16,7 +16,6 @@ class MainCommand extends Command implements TabExecutor {
|
||||
public MainCommand(CommandManager manager) {
|
||||
super("luckpermsbungee", null, "bperms", "lpb", "bpermissions", "bp", "bperm");
|
||||
this.manager = manager;
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
|
||||
@@ -17,7 +17,9 @@ import java.util.concurrent.TimeUnit;
|
||||
|
||||
@AllArgsConstructor
|
||||
public class PlayerListener implements Listener {
|
||||
|
||||
private static final TextComponent WARN_MESSAGE = new TextComponent(Util.color(
|
||||
Message.PREFIX + "Permissions data could not be loaded. Please contact an administrator.")
|
||||
);
|
||||
private final LPBungeePlugin plugin;
|
||||
|
||||
@EventHandler
|
||||
@@ -25,12 +27,13 @@ public class PlayerListener implements Listener {
|
||||
final ProxiedPlayer player = e.getPlayer();
|
||||
final WeakReference<ProxiedPlayer> p = new WeakReference<>(player);
|
||||
|
||||
// Create user async and at post login. We're not concerned if data couldn't be loaded, the player won't be kicked.
|
||||
plugin.getDatastore().loadOrCreateUser(player.getUniqueId(), player.getName(), success -> {
|
||||
if (!success) {
|
||||
plugin.getProxy().getScheduler().schedule(plugin, () -> {
|
||||
final ProxiedPlayer pl = p.get();
|
||||
if (pl != null) {
|
||||
pl.sendMessage(new TextComponent(Util.color(Message.PREFIX + "Permissions data could not be loaded. Please contact an administrator.")));
|
||||
pl.sendMessage(WARN_MESSAGE);
|
||||
}
|
||||
}, 3, TimeUnit.SECONDS);
|
||||
|
||||
@@ -48,10 +51,10 @@ public class PlayerListener implements Listener {
|
||||
|
||||
@EventHandler
|
||||
public void onPlayerQuit(PlayerDisconnectEvent e) {
|
||||
ProxiedPlayer player = e.getPlayer();
|
||||
final ProxiedPlayer player = e.getPlayer();
|
||||
|
||||
// Unload the user from memory when they disconnect
|
||||
User user = plugin.getUserManager().getUser(player.getUniqueId());
|
||||
final User user = plugin.getUserManager().getUser(player.getUniqueId());
|
||||
plugin.getUserManager().unloadUser(user);
|
||||
}
|
||||
}
|
||||
@@ -1,5 +1,5 @@
|
||||
name: LuckPerms
|
||||
author: Luck
|
||||
version: 1.1
|
||||
version: 1.2
|
||||
main: me.lucko.luckperms.LPBungeePlugin
|
||||
description: A permissions plugin
|
||||
+12
-1
@@ -5,7 +5,7 @@
|
||||
<parent>
|
||||
<artifactId>luckperms</artifactId>
|
||||
<groupId>me.lucko</groupId>
|
||||
<version>1.1</version>
|
||||
<version>1.3</version>
|
||||
</parent>
|
||||
<modelVersion>4.0.0</modelVersion>
|
||||
|
||||
@@ -23,4 +23,15 @@
|
||||
</plugin>
|
||||
</plugins>
|
||||
</build>
|
||||
|
||||
<dependencies>
|
||||
<!-- LuckPerms API -->
|
||||
<dependency>
|
||||
<groupId>me.lucko</groupId>
|
||||
<artifactId>luckperms-api</artifactId>
|
||||
<version>${project.parent.version}</version>
|
||||
<scope>compile</scope>
|
||||
</dependency>
|
||||
</dependencies>
|
||||
|
||||
</project>
|
||||
@@ -0,0 +1,90 @@
|
||||
package me.lucko.luckperms.api.implementation;
|
||||
|
||||
import lombok.AllArgsConstructor;
|
||||
import lombok.NonNull;
|
||||
import me.lucko.luckperms.LuckPermsPlugin;
|
||||
import me.lucko.luckperms.api.*;
|
||||
import me.lucko.luckperms.api.implementation.internal.DatastoreLink;
|
||||
import me.lucko.luckperms.api.implementation.internal.GroupLink;
|
||||
import me.lucko.luckperms.api.implementation.internal.TrackLink;
|
||||
import me.lucko.luckperms.api.implementation.internal.UserLink;
|
||||
|
||||
import java.util.UUID;
|
||||
|
||||
/**
|
||||
* Provides static access to LuckPerms
|
||||
*/
|
||||
@AllArgsConstructor
|
||||
public class ApiProvider implements LuckPermsApi {
|
||||
private final LuckPermsPlugin plugin;
|
||||
|
||||
@Override
|
||||
public void runUpdateTask() {
|
||||
plugin.runUpdateTask();
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getVersion() {
|
||||
return plugin.getVersion();
|
||||
}
|
||||
|
||||
@Override
|
||||
public Datastore getDatastore() {
|
||||
return new DatastoreLink(plugin.getDatastore());
|
||||
}
|
||||
|
||||
@Override
|
||||
public User getUser(@NonNull UUID uuid) {
|
||||
final me.lucko.luckperms.users.User user = plugin.getUserManager().getUser(uuid);
|
||||
if (user == null) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return new UserLink(user);
|
||||
}
|
||||
|
||||
@Override
|
||||
public User getUser(@NonNull String name) {
|
||||
final me.lucko.luckperms.users.User user = plugin.getUserManager().getUser(name);
|
||||
if (user == null) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return new UserLink(user);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isUserLoaded(@NonNull UUID uuid) {
|
||||
return plugin.getUserManager().isLoaded(uuid);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Group getGroup(@NonNull String name) {
|
||||
final me.lucko.luckperms.groups.Group group = plugin.getGroupManager().getGroup(name);
|
||||
if (group == null) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return new GroupLink(group);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isGroupLoaded(@NonNull String name) {
|
||||
return plugin.getGroupManager().isLoaded(name);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Track getTrack(@NonNull String name) {
|
||||
final me.lucko.luckperms.tracks.Track track = plugin.getTrackManager().getTrack(name);
|
||||
if (track == null) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return new TrackLink(track);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isTrackLoaded(@NonNull String name) {
|
||||
return plugin.getTrackManager().isLoaded(name);
|
||||
}
|
||||
}
|
||||
+252
@@ -0,0 +1,252 @@
|
||||
package me.lucko.luckperms.api.implementation.internal;
|
||||
|
||||
import lombok.AllArgsConstructor;
|
||||
import lombok.NonNull;
|
||||
import me.lucko.luckperms.api.Datastore;
|
||||
import me.lucko.luckperms.api.Group;
|
||||
import me.lucko.luckperms.api.Track;
|
||||
import me.lucko.luckperms.api.User;
|
||||
import me.lucko.luckperms.api.data.Callback;
|
||||
import me.lucko.luckperms.utils.Patterns;
|
||||
|
||||
import java.util.UUID;
|
||||
|
||||
/**
|
||||
* Provides a link between {@link Datastore} and {@link me.lucko.luckperms.data.Datastore}
|
||||
*/
|
||||
@SuppressWarnings({"unused", "WeakerAccess"})
|
||||
public class DatastoreLink implements Datastore {
|
||||
|
||||
private final me.lucko.luckperms.data.Datastore master;
|
||||
private final Async async;
|
||||
private final Sync sync;
|
||||
|
||||
public DatastoreLink(@NonNull me.lucko.luckperms.data.Datastore master) {
|
||||
this.master = master;
|
||||
this.async = new Async(master);
|
||||
this.sync = new Sync(master);
|
||||
}
|
||||
|
||||
private static String checkUsername(String s) {
|
||||
if (s.length() > 16 || Patterns.NON_USERNAME.matcher(s).find()) {
|
||||
throw new IllegalArgumentException("Invalid username entry '" + s + "'. Usernames must be less than 16 chars" +
|
||||
" and only contain 'a-z A-Z 1-9 _'.");
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
private static String checkName(String s) {
|
||||
if (s.length() > 36 || Patterns.NON_ALPHA_NUMERIC.matcher(s).find()) {
|
||||
throw new IllegalArgumentException("Invalid name entry '" + s + "'. Names must be less than 37 chars" +
|
||||
" and only contain 'a-z A-Z 1-9'.");
|
||||
}
|
||||
return s.toLowerCase();
|
||||
}
|
||||
|
||||
private static Callback checkCallback(Callback c) {
|
||||
// If no callback was given, just send an empty one
|
||||
if (c == null) {
|
||||
c = success -> {};
|
||||
}
|
||||
return c;
|
||||
}
|
||||
|
||||
private static Callback.GetUUID checkCallback(Callback.GetUUID c) {
|
||||
// If no callback was given, just send an empty one
|
||||
if (c == null) {
|
||||
c = success -> {};
|
||||
}
|
||||
return c;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getName() {
|
||||
return master.getName();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isAcceptingLogins() {
|
||||
return master.isAcceptingLogins();
|
||||
}
|
||||
|
||||
@Override
|
||||
public Async async() {
|
||||
return async;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Sync sync() {
|
||||
return sync;
|
||||
}
|
||||
|
||||
@AllArgsConstructor
|
||||
public class Async implements Datastore.Async {
|
||||
private final me.lucko.luckperms.data.Datastore master;
|
||||
|
||||
@Override
|
||||
public void loadOrCreateUser(@NonNull UUID uuid, @NonNull String username, Callback callback) {
|
||||
master.loadOrCreateUser(uuid, checkUsername(username), checkCallback(callback));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void loadUser(@NonNull UUID uuid, Callback callback) {
|
||||
master.loadUser(uuid, checkCallback(callback));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void saveUser(@NonNull User user, Callback callback) {
|
||||
Utils.checkUser(user);
|
||||
master.saveUser(((UserLink) user).getMaster(), checkCallback(callback));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void createAndLoadGroup(@NonNull String name, Callback callback) {
|
||||
master.createAndLoadGroup(checkName(name), checkCallback(callback));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void loadGroup(@NonNull String name, Callback callback) {
|
||||
master.loadGroup(checkName(name), checkCallback(callback));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void loadAllGroups(Callback callback) {
|
||||
master.loadAllGroups(checkCallback(callback));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void saveGroup(@NonNull Group group, Callback callback) {
|
||||
Utils.checkGroup(group);
|
||||
master.saveGroup(((GroupLink) group).getMaster(), checkCallback(callback));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void deleteGroup(@NonNull Group group, Callback callback) {
|
||||
Utils.checkGroup(group);
|
||||
master.deleteGroup(((GroupLink) group).getMaster(), checkCallback(callback));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void createAndLoadTrack(@NonNull String name, Callback callback) {
|
||||
master.createAndLoadTrack(checkName(name), checkCallback(callback));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void loadTrack(@NonNull String name, Callback callback) {
|
||||
master.loadTrack(checkName(name), checkCallback(callback));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void loadAllTracks(Callback callback) {
|
||||
master.loadAllTracks(checkCallback(callback));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void saveTrack(@NonNull Track track, Callback callback) {
|
||||
Utils.checkTrack(track);
|
||||
master.saveTrack(((TrackLink) track).getMaster(), checkCallback(callback));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void deleteTrack(@NonNull Track track, Callback callback) {
|
||||
Utils.checkTrack(track);
|
||||
master.deleteTrack(((TrackLink) track).getMaster(), checkCallback(callback));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void saveUUIDData(@NonNull String username, @NonNull UUID uuid, Callback callback) {
|
||||
master.saveUUIDData(checkUsername(username), uuid, checkCallback(callback));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void getUUID(@NonNull String username, Callback.GetUUID callback) {
|
||||
master.getUUID(checkUsername(username), checkCallback(callback));
|
||||
}
|
||||
}
|
||||
|
||||
@AllArgsConstructor
|
||||
public class Sync implements Datastore.Sync {
|
||||
private final me.lucko.luckperms.data.Datastore master;
|
||||
|
||||
@Override
|
||||
public boolean loadOrCreateUser(@NonNull UUID uuid, @NonNull String username) {
|
||||
return master.loadOrCreateUser(uuid, checkUsername(username));
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean loadUser(@NonNull UUID uuid) {
|
||||
return master.loadUser(uuid);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean saveUser(@NonNull User user) {
|
||||
Utils.checkUser(user);
|
||||
return master.saveUser(((UserLink) user).getMaster());
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean createAndLoadGroup(@NonNull String name) {
|
||||
return master.createAndLoadGroup(checkName(name));
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean loadGroup(@NonNull String name) {
|
||||
return master.loadGroup(checkName(name));
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean loadAllGroups() {
|
||||
return master.loadAllGroups();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean saveGroup(@NonNull Group group) {
|
||||
Utils.checkGroup(group);
|
||||
return master.saveGroup(((GroupLink) group).getMaster());
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean deleteGroup(@NonNull Group group) {
|
||||
Utils.checkGroup(group);
|
||||
return master.deleteGroup(((GroupLink) group).getMaster());
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean createAndLoadTrack(@NonNull String name) {
|
||||
return master.createAndLoadTrack(checkName(name));
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean loadTrack(@NonNull String name) {
|
||||
return master.loadTrack(checkName(name));
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean loadAllTracks() {
|
||||
return master.loadAllTracks();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean saveTrack(@NonNull Track track) {
|
||||
Utils.checkTrack(track);
|
||||
return master.saveTrack(((TrackLink) track).getMaster());
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean deleteTrack(@NonNull Track track) {
|
||||
Utils.checkTrack(track);
|
||||
return master.deleteTrack(((TrackLink) track).getMaster());
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean saveUUIDData(@NonNull String username, @NonNull UUID uuid) {
|
||||
return master.saveUUIDData(checkUsername(username), uuid);
|
||||
}
|
||||
|
||||
@Override
|
||||
public UUID getUUID(@NonNull String username) {
|
||||
return master.getUUID(checkUsername(username));
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,31 @@
|
||||
package me.lucko.luckperms.api.implementation.internal;
|
||||
|
||||
import lombok.AccessLevel;
|
||||
import lombok.Getter;
|
||||
import lombok.NonNull;
|
||||
import me.lucko.luckperms.api.Group;
|
||||
|
||||
/**
|
||||
* Provides a link between {@link Group} and {@link me.lucko.luckperms.groups.Group}
|
||||
*/
|
||||
@SuppressWarnings("unused")
|
||||
public class GroupLink extends PermissionObjectLink implements Group {
|
||||
|
||||
@Getter(AccessLevel.PACKAGE)
|
||||
private final me.lucko.luckperms.groups.Group master;
|
||||
|
||||
public GroupLink(@NonNull me.lucko.luckperms.groups.Group master) {
|
||||
super(master);
|
||||
this.master = master;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getName() {
|
||||
return master.getName();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void clearNodes() {
|
||||
master.clearNodes();
|
||||
}
|
||||
}
|
||||
+147
@@ -0,0 +1,147 @@
|
||||
package me.lucko.luckperms.api.implementation.internal;
|
||||
|
||||
import lombok.AccessLevel;
|
||||
import lombok.AllArgsConstructor;
|
||||
import lombok.NonNull;
|
||||
import me.lucko.luckperms.api.PermissionObject;
|
||||
import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
|
||||
import me.lucko.luckperms.exceptions.ObjectLacksException;
|
||||
import me.lucko.luckperms.utils.DateUtil;
|
||||
import me.lucko.luckperms.utils.Patterns;
|
||||
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* Provides a link between {@link PermissionObject} and {@link me.lucko.luckperms.utils.PermissionObject}
|
||||
*/
|
||||
@SuppressWarnings("unused")
|
||||
@AllArgsConstructor(access = AccessLevel.PACKAGE)
|
||||
class PermissionObjectLink implements PermissionObject {
|
||||
|
||||
@NonNull
|
||||
private final me.lucko.luckperms.utils.PermissionObject master;
|
||||
|
||||
static String checkServer(String s) {
|
||||
if (Patterns.NON_ALPHA_NUMERIC.matcher(s).find()) {
|
||||
throw new IllegalArgumentException("Invalid server entry '" + s + "'. Server names can only contain alphanumeric characters.");
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
private static String checkNode(String s) {
|
||||
if (s.contains("/") || s.contains("$")) {
|
||||
throw new IllegalArgumentException("Invalid node entry '" + s + "'. Nodes cannot contain '/' or '$' characters.");
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
static long checkTime(long l) {
|
||||
if (DateUtil.shouldExpire(l)) {
|
||||
throw new IllegalArgumentException("Unix time '" + l + "' is invalid, as it has already passed.");
|
||||
}
|
||||
return l;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getObjectName() {
|
||||
return master.getObjectName();
|
||||
}
|
||||
|
||||
@Override
|
||||
public Map<String, Boolean> getNodes() {
|
||||
return Collections.unmodifiableMap(master.getNodes());
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean hasPermission(@NonNull String node, @NonNull boolean b) {
|
||||
return master.hasPermission(node, b);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean hasPermission(@NonNull String node, @NonNull boolean b, @NonNull String server) {
|
||||
return master.hasPermission(node, b, checkServer(server));
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean hasPermission(@NonNull String node, @NonNull boolean b, @NonNull boolean temporary) {
|
||||
return master.hasPermission(node, b, temporary);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean inheritsPermission(@NonNull String node, @NonNull boolean b) {
|
||||
return master.inheritsPermission(node, b);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean inheritsPermission(@NonNull String node, @NonNull boolean b, @NonNull String server) {
|
||||
return master.inheritsPermission(node, b, checkServer(server));
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean inheritsPermission(@NonNull String node, @NonNull boolean b, @NonNull boolean temporary) {
|
||||
return master.inheritsPermission(node, b, temporary);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setPermission(@NonNull String node, @NonNull boolean value) throws ObjectAlreadyHasException {
|
||||
master.setPermission(checkNode(node), value);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setPermission(@NonNull String node, @NonNull boolean value, @NonNull String server) throws ObjectAlreadyHasException {
|
||||
master.setPermission(checkNode(node), value, checkServer(server));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setPermission(@NonNull String node, @NonNull boolean value, @NonNull long expireAt) throws ObjectAlreadyHasException {
|
||||
master.setPermission(checkNode(node), value, checkTime(expireAt));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setPermission(@NonNull String node, @NonNull boolean value, @NonNull String server, @NonNull long expireAt) throws ObjectAlreadyHasException {
|
||||
master.setPermission(checkNode(node), value, checkServer(server), checkTime(expireAt));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void unsetPermission(@NonNull String node, @NonNull boolean temporary) throws ObjectLacksException {
|
||||
master.unsetPermission(checkNode(node), temporary);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void unsetPermission(@NonNull String node) throws ObjectLacksException {
|
||||
master.unsetPermission(checkNode(node));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void unsetPermission(@NonNull String node, @NonNull String server) throws ObjectLacksException {
|
||||
master.unsetPermission(checkNode(node), checkServer(server));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void unsetPermission(@NonNull String node, @NonNull String server, @NonNull boolean temporary) throws ObjectLacksException {
|
||||
master.unsetPermission(checkNode(node), checkServer(server), temporary);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Map<String, Boolean> getLocalPermissions(String server, List<String> excludedGroups) {
|
||||
return master.getLocalPermissions(server, excludedGroups);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Map<Map.Entry<String, Boolean>, Long> getTemporaryNodes() {
|
||||
return master.getTemporaryNodes();
|
||||
}
|
||||
|
||||
@Override
|
||||
public Map<String, Boolean> getPermanentNodes() {
|
||||
return master.getPermanentNodes();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void auditTemporaryPermissions() {
|
||||
master.auditTemporaryPermissions();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,90 @@
|
||||
package me.lucko.luckperms.api.implementation.internal;
|
||||
|
||||
import lombok.AccessLevel;
|
||||
import lombok.AllArgsConstructor;
|
||||
import lombok.Getter;
|
||||
import lombok.NonNull;
|
||||
import me.lucko.luckperms.api.Group;
|
||||
import me.lucko.luckperms.api.Track;
|
||||
import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
|
||||
import me.lucko.luckperms.exceptions.ObjectLacksException;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Provides a link between {@link Track} and {@link me.lucko.luckperms.tracks.Track}
|
||||
*/
|
||||
@SuppressWarnings("unused")
|
||||
@AllArgsConstructor
|
||||
public class TrackLink implements Track {
|
||||
|
||||
@NonNull
|
||||
@Getter(AccessLevel.PACKAGE)
|
||||
private final me.lucko.luckperms.tracks.Track master;
|
||||
|
||||
@Override
|
||||
public String getName() {
|
||||
return master.getName();
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<String> getGroups() {
|
||||
return master.getGroups();
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getSize() {
|
||||
return master.getSize();
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getNext(@NonNull Group current) throws ObjectLacksException {
|
||||
Utils.checkGroup(current);
|
||||
return master.getNext(((GroupLink) current).getMaster());
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getPrevious(@NonNull Group current) throws ObjectLacksException {
|
||||
Utils.checkGroup(current);
|
||||
return master.getPrevious(((GroupLink) current).getMaster());
|
||||
}
|
||||
|
||||
@Override
|
||||
public void appendGroup(@NonNull Group group) throws ObjectAlreadyHasException {
|
||||
Utils.checkGroup(group);
|
||||
master.appendGroup(((GroupLink) group).getMaster());
|
||||
}
|
||||
|
||||
@Override
|
||||
public void insertGroup(@NonNull Group group, @NonNull int position) throws ObjectAlreadyHasException, IndexOutOfBoundsException {
|
||||
Utils.checkGroup(group);
|
||||
master.insertGroup(((GroupLink) group).getMaster(), position);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void removeGroup(@NonNull Group group) throws ObjectLacksException {
|
||||
Utils.checkGroup(group);
|
||||
master.removeGroup(((GroupLink) group).getMaster());
|
||||
}
|
||||
|
||||
@Override
|
||||
public void removeGroup(@NonNull String group) throws ObjectLacksException {
|
||||
master.removeGroup(group);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean containsGroup(@NonNull Group group) {
|
||||
Utils.checkGroup(group);
|
||||
return master.containsGroup(((GroupLink) group).getMaster());
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean containsGroup(@NonNull String group) {
|
||||
return master.containsGroup(group);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void clearGroups() {
|
||||
master.clearGroups();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,136 @@
|
||||
package me.lucko.luckperms.api.implementation.internal;
|
||||
|
||||
import lombok.AccessLevel;
|
||||
import lombok.Getter;
|
||||
import lombok.NonNull;
|
||||
import me.lucko.luckperms.api.Group;
|
||||
import me.lucko.luckperms.api.User;
|
||||
import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
|
||||
import me.lucko.luckperms.exceptions.ObjectLacksException;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.UUID;
|
||||
|
||||
/**
|
||||
* Provides a link between {@link User} and {@link me.lucko.luckperms.users.User}
|
||||
*/
|
||||
@SuppressWarnings("unused")
|
||||
public class UserLink extends PermissionObjectLink implements User {
|
||||
|
||||
@Getter(AccessLevel.PACKAGE)
|
||||
private final me.lucko.luckperms.users.User master;
|
||||
|
||||
public UserLink(@NonNull me.lucko.luckperms.users.User master) {
|
||||
super(master);
|
||||
this.master = master;
|
||||
}
|
||||
|
||||
@Override
|
||||
public UUID getUuid() {
|
||||
return master.getUuid();
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getName() {
|
||||
return master.getName();
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getPrimaryGroup() {
|
||||
return master.getPrimaryGroup();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setPrimaryGroup(String s) throws ObjectAlreadyHasException {
|
||||
if (getPrimaryGroup().equalsIgnoreCase(s)) {
|
||||
throw new ObjectAlreadyHasException();
|
||||
}
|
||||
|
||||
if (!getGroupNames().contains(s.toLowerCase())) {
|
||||
throw new IllegalStateException("User is not a member of that group.");
|
||||
}
|
||||
|
||||
master.setPrimaryGroup(s.toLowerCase());
|
||||
}
|
||||
|
||||
@Override
|
||||
public void refreshPermissions() {
|
||||
master.refreshPermissions();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isInGroup(@NonNull Group group) {
|
||||
Utils.checkGroup(group);
|
||||
return master.isInGroup(((GroupLink) group).getMaster());
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isInGroup(@NonNull Group group, @NonNull String server) {
|
||||
Utils.checkGroup(group);
|
||||
return master.isInGroup(((GroupLink) group).getMaster(), server);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void addGroup(@NonNull Group group) throws ObjectAlreadyHasException {
|
||||
Utils.checkGroup(group);
|
||||
master.addGroup(((GroupLink) group).getMaster());
|
||||
}
|
||||
|
||||
@Override
|
||||
public void addGroup(@NonNull Group group, @NonNull String server) throws ObjectAlreadyHasException {
|
||||
Utils.checkGroup(group);
|
||||
master.addGroup(((GroupLink) group).getMaster(), checkServer(server));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void addGroup(@NonNull Group group, @NonNull long expireAt) throws ObjectAlreadyHasException {
|
||||
Utils.checkGroup(group);
|
||||
master.addGroup(((GroupLink) group).getMaster(), checkTime(expireAt));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void addGroup(@NonNull Group group, @NonNull String server, @NonNull long expireAt) throws ObjectAlreadyHasException {
|
||||
Utils.checkGroup(group);
|
||||
master.addGroup(((GroupLink) group).getMaster(), checkServer(server), checkTime(expireAt));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void removeGroup(@NonNull Group group) throws ObjectLacksException {
|
||||
Utils.checkGroup(group);
|
||||
master.removeGroup(((GroupLink) group).getMaster());
|
||||
}
|
||||
|
||||
@Override
|
||||
public void removeGroup(@NonNull Group group, @NonNull boolean temporary) throws ObjectLacksException {
|
||||
Utils.checkGroup(group);
|
||||
master.removeGroup(((GroupLink) group).getMaster(), temporary);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void removeGroup(@NonNull Group group, @NonNull String server) throws ObjectLacksException {
|
||||
Utils.checkGroup(group);
|
||||
master.removeGroup(((GroupLink) group).getMaster(), checkServer(server));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void removeGroup(@NonNull Group group, @NonNull String server, @NonNull boolean temporary) throws ObjectLacksException {
|
||||
Utils.checkGroup(group);
|
||||
master.removeGroup(((GroupLink) group).getMaster(), checkServer(server), temporary);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void clearNodes() {
|
||||
master.clearNodes();
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<String> getGroupNames() {
|
||||
return master.getGroupNames();
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<String> getLocalGroups(@NonNull String server) {
|
||||
return master.getLocalGroups(checkServer(server));
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
package me.lucko.luckperms.api.implementation.internal;
|
||||
|
||||
import me.lucko.luckperms.api.Group;
|
||||
import me.lucko.luckperms.api.Track;
|
||||
import me.lucko.luckperms.api.User;
|
||||
|
||||
class Utils {
|
||||
|
||||
static void checkUser(User user) {
|
||||
if (!(user instanceof UserLink)) {
|
||||
throw new IllegalArgumentException("User instance cannot be handled by this implementation.");
|
||||
}
|
||||
}
|
||||
|
||||
static void checkGroup(Group group) {
|
||||
if (!(group instanceof GroupLink)) {
|
||||
throw new IllegalArgumentException("Group instance cannot be handled by this implementation.");
|
||||
}
|
||||
}
|
||||
|
||||
static void checkTrack(Track track) {
|
||||
if (!(track instanceof TrackLink)) {
|
||||
throw new IllegalArgumentException("Track instance cannot be handled by this implementation.");
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -2,17 +2,17 @@ package me.lucko.luckperms.commands;
|
||||
|
||||
import lombok.Getter;
|
||||
import me.lucko.luckperms.LuckPermsPlugin;
|
||||
import me.lucko.luckperms.commands.group.CreateGroupCommand;
|
||||
import me.lucko.luckperms.commands.group.DeleteGroupCommand;
|
||||
import me.lucko.luckperms.commands.group.CreateGroup;
|
||||
import me.lucko.luckperms.commands.group.DeleteGroup;
|
||||
import me.lucko.luckperms.commands.group.GroupMainCommand;
|
||||
import me.lucko.luckperms.commands.group.ListGroupsCommand;
|
||||
import me.lucko.luckperms.commands.group.ListGroups;
|
||||
import me.lucko.luckperms.commands.group.subcommands.*;
|
||||
import me.lucko.luckperms.commands.misc.DebugCommand;
|
||||
import me.lucko.luckperms.commands.misc.InfoCommand;
|
||||
import me.lucko.luckperms.commands.misc.SyncCommand;
|
||||
import me.lucko.luckperms.commands.track.CreateTrackCommand;
|
||||
import me.lucko.luckperms.commands.track.DeleteTrackCommand;
|
||||
import me.lucko.luckperms.commands.track.ListTracksCommand;
|
||||
import me.lucko.luckperms.commands.track.CreateTrack;
|
||||
import me.lucko.luckperms.commands.track.DeleteTrack;
|
||||
import me.lucko.luckperms.commands.track.ListTracks;
|
||||
import me.lucko.luckperms.commands.track.TrackMainCommand;
|
||||
import me.lucko.luckperms.commands.track.subcommands.*;
|
||||
import me.lucko.luckperms.commands.user.UserMainCommand;
|
||||
@@ -37,52 +37,60 @@ public class CommandManager {
|
||||
|
||||
UserMainCommand userCommand = new UserMainCommand();
|
||||
this.registerMainCommand(userCommand);
|
||||
userCommand.registerSubCommand(new UserAddGroupCommand());
|
||||
userCommand.registerSubCommand(new UserClearCommand());
|
||||
userCommand.registerSubCommand(new UserDemoteCommand());
|
||||
userCommand.registerSubCommand(new UserGetUUIDCommand());
|
||||
userCommand.registerSubCommand(new UserHasPermCommand());
|
||||
userCommand.registerSubCommand(new UserInfoCommand());
|
||||
userCommand.registerSubCommand(new UserInheritsPermCommand());
|
||||
userCommand.registerSubCommand(new UserListNodesCommand());
|
||||
userCommand.registerSubCommand(new UserPromoteCommand());
|
||||
userCommand.registerSubCommand(new UserRemoveGroupCommand());
|
||||
userCommand.registerSubCommand(new UserSetPermissionCommand());
|
||||
userCommand.registerSubCommand(new UserSetPrimaryGroupCommand());
|
||||
userCommand.registerSubCommand(new UserShowPosCommand());
|
||||
userCommand.registerSubCommand(new UserShowTracksCommand());
|
||||
userCommand.registerSubCommand(new UserUnSetPermissionCommand());
|
||||
userCommand.registerSubCommand(new UserInfo());
|
||||
userCommand.registerSubCommand(new UserGetUUID());
|
||||
userCommand.registerSubCommand(new UserListNodes());
|
||||
userCommand.registerSubCommand(new UserHasPerm());
|
||||
userCommand.registerSubCommand(new UserInheritsPerm());
|
||||
userCommand.registerSubCommand(new UserSetPermission());
|
||||
userCommand.registerSubCommand(new UserUnSetPermission());
|
||||
userCommand.registerSubCommand(new UserAddGroup());
|
||||
userCommand.registerSubCommand(new UserRemoveGroup());
|
||||
userCommand.registerSubCommand(new UserSetTempPermission());
|
||||
userCommand.registerSubCommand(new UserUnsetTempPermission());
|
||||
userCommand.registerSubCommand(new UserAddTempGroup());
|
||||
userCommand.registerSubCommand(new UserRemoveTempGroup());
|
||||
userCommand.registerSubCommand(new UserSetPrimaryGroup());
|
||||
userCommand.registerSubCommand(new UserShowTracks());
|
||||
userCommand.registerSubCommand(new UserPromote());
|
||||
userCommand.registerSubCommand(new UserDemote());
|
||||
userCommand.registerSubCommand(new UserShowPos());
|
||||
userCommand.registerSubCommand(new UserClear());
|
||||
|
||||
GroupMainCommand groupCommand = new GroupMainCommand();
|
||||
this.registerMainCommand(groupCommand);
|
||||
groupCommand.registerSubCommand(new GroupClearCommand());
|
||||
groupCommand.registerSubCommand(new GroupHasPermCommand());
|
||||
groupCommand.registerSubCommand(new GroupInfoCommand());
|
||||
groupCommand.registerSubCommand(new GroupInheritsPermCommand());
|
||||
groupCommand.registerSubCommand(new GroupListNodesCommand());
|
||||
groupCommand.registerSubCommand(new GroupSetInheritCommand());
|
||||
groupCommand.registerSubCommand(new GroupSetPermissionCommand());
|
||||
groupCommand.registerSubCommand(new GroupShowTracksCommand());
|
||||
groupCommand.registerSubCommand(new GroupUnsetInheritCommand());
|
||||
groupCommand.registerSubCommand(new GroupUnSetPermissionCommand());
|
||||
groupCommand.registerSubCommand(new GroupInfo());
|
||||
groupCommand.registerSubCommand(new GroupListNodes());
|
||||
groupCommand.registerSubCommand(new GroupHasPerm());
|
||||
groupCommand.registerSubCommand(new GroupInheritsPerm());
|
||||
groupCommand.registerSubCommand(new GroupSetPermission());
|
||||
groupCommand.registerSubCommand(new GroupUnSetPermission());
|
||||
groupCommand.registerSubCommand(new GroupSetInherit());
|
||||
groupCommand.registerSubCommand(new GroupUnsetInherit());
|
||||
groupCommand.registerSubCommand(new GroupSetTempPermission());
|
||||
groupCommand.registerSubCommand(new GroupUnsetTempPermission());
|
||||
groupCommand.registerSubCommand(new GroupSetTempInherit());
|
||||
groupCommand.registerSubCommand(new GroupUnsetTempInherit());
|
||||
groupCommand.registerSubCommand(new GroupShowTracks());
|
||||
groupCommand.registerSubCommand(new GroupClear());
|
||||
|
||||
TrackMainCommand trackCommand = new TrackMainCommand();
|
||||
this.registerMainCommand(trackCommand);
|
||||
trackCommand.registerSubCommand(new TrackAppendCommand());
|
||||
trackCommand.registerSubCommand(new TrackClearCommand());
|
||||
trackCommand.registerSubCommand(new TrackInfoCommand());
|
||||
trackCommand.registerSubCommand(new TrackInsertCommand());
|
||||
trackCommand.registerSubCommand(new TrackRemoveCommand());
|
||||
trackCommand.registerSubCommand(new TrackInfo());
|
||||
trackCommand.registerSubCommand(new TrackAppend());
|
||||
trackCommand.registerSubCommand(new TrackInsert());
|
||||
trackCommand.registerSubCommand(new TrackRemove());
|
||||
trackCommand.registerSubCommand(new TrackClear());
|
||||
|
||||
this.registerMainCommand(new CreateGroupCommand());
|
||||
this.registerMainCommand(new DeleteGroupCommand());
|
||||
this.registerMainCommand(new ListGroupsCommand());
|
||||
this.registerMainCommand(new CreateTrackCommand());
|
||||
this.registerMainCommand(new DeleteTrackCommand());
|
||||
this.registerMainCommand(new ListTracksCommand());
|
||||
this.registerMainCommand(new DebugCommand());
|
||||
this.registerMainCommand(new InfoCommand());
|
||||
this.registerMainCommand(new SyncCommand());
|
||||
this.registerMainCommand(new InfoCommand());
|
||||
this.registerMainCommand(new DebugCommand());
|
||||
this.registerMainCommand(new CreateGroup());
|
||||
this.registerMainCommand(new DeleteGroup());
|
||||
this.registerMainCommand(new ListGroups());
|
||||
this.registerMainCommand(new CreateTrack());
|
||||
this.registerMainCommand(new DeleteTrack());
|
||||
this.registerMainCommand(new ListTracks());
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -139,7 +147,8 @@ public class CommandManager {
|
||||
return mains.stream().map(MainCommand::getName).map(String::toLowerCase).collect(Collectors.toList());
|
||||
}
|
||||
|
||||
return mains.stream().map(MainCommand::getName).map(String::toLowerCase).filter(s -> s.startsWith(args.get(0).toLowerCase())).collect(Collectors.toList());
|
||||
return mains.stream().map(MainCommand::getName).map(String::toLowerCase)
|
||||
.filter(s -> s.startsWith(args.get(0).toLowerCase())).collect(Collectors.toList());
|
||||
}
|
||||
|
||||
Optional<MainCommand> o = mains.stream().filter(m -> m.getName().equalsIgnoreCase(args.get(0))).limit(1).findAny();
|
||||
|
||||
@@ -1,5 +1,8 @@
|
||||
package me.lucko.luckperms.commands;
|
||||
|
||||
/**
|
||||
* Wrapper class to represent a CommandSender in Bukkit/Bungee within the luckperms-common command implementations.
|
||||
*/
|
||||
public interface Sender {
|
||||
|
||||
void sendMessage(String s);
|
||||
|
||||
@@ -4,6 +4,7 @@ import lombok.AllArgsConstructor;
|
||||
import lombok.Getter;
|
||||
import me.lucko.luckperms.LuckPermsPlugin;
|
||||
import me.lucko.luckperms.constants.Permission;
|
||||
import me.lucko.luckperms.users.User;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
@@ -11,6 +12,13 @@ import java.util.Collections;
|
||||
import java.util.List;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
/**
|
||||
* Abstract SubCommand class
|
||||
* Doesn't declare any abstract onCommand methods, as sub classes declare their own with parameters unique to the sub command type.
|
||||
* For example, see: {@link me.lucko.luckperms.commands.user.UserSubCommand#execute(LuckPermsPlugin, Sender, User, List, String)}
|
||||
*
|
||||
* SubCommand #execute methods are always called from the {@link MainCommand} class related to them, so abstraction is not needed.
|
||||
*/
|
||||
@Getter
|
||||
@AllArgsConstructor
|
||||
public abstract class SubCommand {
|
||||
@@ -19,6 +27,25 @@ public abstract class SubCommand {
|
||||
private final String usage;
|
||||
private final Permission permission;
|
||||
|
||||
public abstract boolean isArgLengthInvalid(int argLength);
|
||||
|
||||
public boolean isAuthorized(Sender sender) {
|
||||
return permission.isAuthorized(sender);
|
||||
}
|
||||
|
||||
public void sendUsage(Sender sender, String label) {
|
||||
Util.sendPluginMessage(sender, "&e-> &d" + String.format(getUsage(), label));
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a list of suggestions, which are empty by default. Sub classes that give tab complete suggestions override
|
||||
* this method to give their own list.
|
||||
*/
|
||||
public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
|
||||
return Collections.emptyList();
|
||||
}
|
||||
|
||||
/* Utility methods used by #onTabComplete implementations in sub classes */
|
||||
protected static List<String> getGroupTabComplete(List<String> args, LuckPermsPlugin plugin) {
|
||||
return getTabComplete(new ArrayList<>(plugin.getGroupManager().getGroups().keySet()), args);
|
||||
}
|
||||
@@ -27,6 +54,14 @@ public abstract class SubCommand {
|
||||
return getTabComplete(new ArrayList<>(plugin.getTrackManager().getTracks().keySet()), args);
|
||||
}
|
||||
|
||||
protected static List<String> getBoolTabComplete(List<String> args) {
|
||||
if (args.size() == 2) {
|
||||
return Arrays.asList("true", "false");
|
||||
} else {
|
||||
return Collections.emptyList();
|
||||
}
|
||||
}
|
||||
|
||||
private static List<String> getTabComplete(List<String> options, List<String> args) {
|
||||
if (args.size() <= 1) {
|
||||
if (args.isEmpty() || args.get(0).equalsIgnoreCase("")) {
|
||||
@@ -38,26 +73,4 @@ public abstract class SubCommand {
|
||||
|
||||
return Collections.emptyList();
|
||||
}
|
||||
|
||||
protected static List<String> getBoolTabComplete(List<String> args) {
|
||||
if (args.size() == 2) {
|
||||
return Arrays.asList("true", "false");
|
||||
} else {
|
||||
return Collections.emptyList();
|
||||
}
|
||||
}
|
||||
|
||||
public boolean isAuthorized(Sender sender) {
|
||||
return permission.isAuthorized(sender);
|
||||
}
|
||||
|
||||
public void sendUsage(Sender sender, String label) {
|
||||
Util.sendPluginMessage(sender, "&e-> &d" + String.format(getUsage(), label));
|
||||
}
|
||||
|
||||
public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
|
||||
return Collections.emptyList();
|
||||
}
|
||||
|
||||
public abstract boolean isArgLengthInvalid(int argLength);
|
||||
}
|
||||
@@ -1,15 +1,16 @@
|
||||
package me.lucko.luckperms.commands;
|
||||
|
||||
import lombok.experimental.UtilityClass;
|
||||
import me.lucko.luckperms.constants.Message;
|
||||
import me.lucko.luckperms.utils.DateUtil;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.UUID;
|
||||
|
||||
@UtilityClass
|
||||
public class Util {
|
||||
|
||||
private Util() {}
|
||||
|
||||
public static void sendPluginMessage(Sender sender, String message) {
|
||||
sender.sendMessage(color(Message.PREFIX + message));
|
||||
}
|
||||
@@ -86,7 +87,7 @@ public class Util {
|
||||
return sb.delete(sb.length() - 6, sb.length()).toString();
|
||||
}
|
||||
|
||||
public static String nodesToString(Map<String, Boolean> nodes) {
|
||||
public static String permNodesToString(Map<String, Boolean> nodes) {
|
||||
if (nodes.isEmpty()) return "&6None";
|
||||
|
||||
StringBuilder sb = new StringBuilder();
|
||||
@@ -102,6 +103,24 @@ public class Util {
|
||||
return sb.delete(sb.length() - 2, sb.length()).toString();
|
||||
}
|
||||
|
||||
public static String tempNodesToString(Map<Map.Entry<String, Boolean>, Long> nodes) {
|
||||
if (nodes.isEmpty()) return "&6None";
|
||||
|
||||
StringBuilder sb = new StringBuilder();
|
||||
|
||||
for (Map.Entry<Map.Entry<String, Boolean>, Long> e : nodes.entrySet()) {
|
||||
if (e.getKey().getValue()) {
|
||||
sb.append("&a").append(e.getKey().getKey()).append("&6 - expires in ")
|
||||
.append(DateUtil.formatDateDiff(e.getValue())).append("\n");
|
||||
} else {
|
||||
sb.append("&c").append(e.getKey().getKey()).append("&6 - expires in ")
|
||||
.append(DateUtil.formatDateDiff(e.getValue())).append("\n");
|
||||
}
|
||||
}
|
||||
|
||||
return sb.toString();
|
||||
}
|
||||
|
||||
public static UUID parseUuid(String s) {
|
||||
try {
|
||||
return UUID.fromString(s);
|
||||
|
||||
+2
-2
@@ -11,8 +11,8 @@ import me.lucko.luckperms.utils.Patterns;
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
|
||||
public class CreateGroupCommand extends MainCommand {
|
||||
public CreateGroupCommand() {
|
||||
public class CreateGroup extends MainCommand {
|
||||
public CreateGroup() {
|
||||
super("CreateGroup", "/%s creategroup <group>", 1);
|
||||
}
|
||||
|
||||
+8
-2
@@ -7,14 +7,15 @@ import me.lucko.luckperms.commands.SubCommand;
|
||||
import me.lucko.luckperms.constants.Message;
|
||||
import me.lucko.luckperms.constants.Permission;
|
||||
import me.lucko.luckperms.groups.Group;
|
||||
import me.lucko.luckperms.utils.Patterns;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
public class DeleteGroupCommand extends MainCommand {
|
||||
public DeleteGroupCommand() {
|
||||
public class DeleteGroup extends MainCommand {
|
||||
public DeleteGroup() {
|
||||
super("DeleteGroup", "/%s deletegroup <group>", 1);
|
||||
}
|
||||
|
||||
@@ -32,6 +33,11 @@ public class DeleteGroupCommand extends MainCommand {
|
||||
return;
|
||||
}
|
||||
|
||||
if (Patterns.NON_ALPHA_NUMERIC.matcher(groupName).find()) {
|
||||
Message.GROUP_INVALID_ENTRY.send(sender);
|
||||
return;
|
||||
}
|
||||
|
||||
plugin.getDatastore().loadGroup(groupName, success -> {
|
||||
if (!success) {
|
||||
Message.GROUP_DOES_NOT_EXIST.send(sender);
|
||||
@@ -6,6 +6,7 @@ import me.lucko.luckperms.commands.Sender;
|
||||
import me.lucko.luckperms.commands.SubCommand;
|
||||
import me.lucko.luckperms.constants.Message;
|
||||
import me.lucko.luckperms.groups.Group;
|
||||
import me.lucko.luckperms.utils.Patterns;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
@@ -51,6 +52,12 @@ public class GroupMainCommand extends MainCommand {
|
||||
}
|
||||
|
||||
final String groupName = args.get(0).toLowerCase();
|
||||
|
||||
if (Patterns.NON_ALPHA_NUMERIC.matcher(groupName).find()) {
|
||||
Message.GROUP_INVALID_ENTRY.send(sender);
|
||||
return;
|
||||
}
|
||||
|
||||
plugin.getDatastore().loadGroup(groupName, success -> {
|
||||
if (!success) {
|
||||
Message.GROUP_NOT_FOUND.send(sender);
|
||||
|
||||
+2
-2
@@ -12,8 +12,8 @@ import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
|
||||
public class ListGroupsCommand extends MainCommand {
|
||||
public ListGroupsCommand() {
|
||||
public class ListGroups extends MainCommand {
|
||||
public ListGroups() {
|
||||
super("ListGroups", "/%s listgroups", 0);
|
||||
}
|
||||
|
||||
+2
-2
@@ -9,8 +9,8 @@ import me.lucko.luckperms.groups.Group;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class GroupClearCommand extends GroupSubCommand {
|
||||
public GroupClearCommand() {
|
||||
public class GroupClear extends GroupSubCommand {
|
||||
public GroupClear() {
|
||||
super("clear", "Clears a groups permissions", "/%s group <group> clear", Permission.GROUP_CLEAR);
|
||||
}
|
||||
|
||||
+9
-2
@@ -4,13 +4,15 @@ import me.lucko.luckperms.LuckPermsPlugin;
|
||||
import me.lucko.luckperms.commands.Sender;
|
||||
import me.lucko.luckperms.commands.Util;
|
||||
import me.lucko.luckperms.commands.group.GroupSubCommand;
|
||||
import me.lucko.luckperms.constants.Message;
|
||||
import me.lucko.luckperms.constants.Permission;
|
||||
import me.lucko.luckperms.groups.Group;
|
||||
import me.lucko.luckperms.utils.Patterns;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class GroupHasPermCommand extends GroupSubCommand {
|
||||
public GroupHasPermCommand() {
|
||||
public class GroupHasPerm extends GroupSubCommand {
|
||||
public GroupHasPerm() {
|
||||
super("haspermission", "Checks to see if a group has a certain permission node",
|
||||
"/%s group <group> haspermission <node> [server]", Permission.GROUP_HASPERMISSION);
|
||||
}
|
||||
@@ -18,6 +20,11 @@ public class GroupHasPermCommand extends GroupSubCommand {
|
||||
@Override
|
||||
protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
|
||||
if (args.size() == 2) {
|
||||
if (Patterns.NON_ALPHA_NUMERIC.matcher(args.get(1)).find()) {
|
||||
Message.SERVER_INVALID_ENTRY.send(sender);
|
||||
return;
|
||||
}
|
||||
|
||||
Util.sendBoolean(sender, args.get(0), group.hasPermission(args.get(0), true, args.get(1).toLowerCase()));
|
||||
} else {
|
||||
Util.sendBoolean(sender, args.get(0), group.hasPermission(args.get(0), true, "global"));
|
||||
+4
-3
@@ -9,14 +9,15 @@ import me.lucko.luckperms.groups.Group;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class GroupInfoCommand extends GroupSubCommand {
|
||||
public GroupInfoCommand() {
|
||||
public class GroupInfo extends GroupSubCommand {
|
||||
public GroupInfo() {
|
||||
super("info", "Gives info about the group", "/%s group <group> info", Permission.GROUP_INFO);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
|
||||
Message.GROUP_INFO.send(sender, group.getName(), group.getNodes().keySet().size(), label, group.getName());
|
||||
Message.GROUP_INFO.send(sender, group.getName(), group.getPermanentNodes().keySet().size(),
|
||||
group.getTemporaryNodes().keySet().size(), label, group.getName());
|
||||
}
|
||||
|
||||
@Override
|
||||
+9
-2
@@ -4,13 +4,15 @@ import me.lucko.luckperms.LuckPermsPlugin;
|
||||
import me.lucko.luckperms.commands.Sender;
|
||||
import me.lucko.luckperms.commands.Util;
|
||||
import me.lucko.luckperms.commands.group.GroupSubCommand;
|
||||
import me.lucko.luckperms.constants.Message;
|
||||
import me.lucko.luckperms.constants.Permission;
|
||||
import me.lucko.luckperms.groups.Group;
|
||||
import me.lucko.luckperms.utils.Patterns;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class GroupInheritsPermCommand extends GroupSubCommand {
|
||||
public GroupInheritsPermCommand() {
|
||||
public class GroupInheritsPerm extends GroupSubCommand {
|
||||
public GroupInheritsPerm() {
|
||||
super("inheritspermission", "Checks to see if a group inherits a certain permission node",
|
||||
"/%s group <group> inheritspermission <node> [server]", Permission.GROUP_INHERITSPERMISSION);
|
||||
}
|
||||
@@ -18,6 +20,11 @@ public class GroupInheritsPermCommand extends GroupSubCommand {
|
||||
@Override
|
||||
protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
|
||||
if (args.size() == 2) {
|
||||
if (Patterns.NON_ALPHA_NUMERIC.matcher(args.get(1)).find()) {
|
||||
Message.SERVER_INVALID_ENTRY.send(sender);
|
||||
return;
|
||||
}
|
||||
|
||||
Util.sendBoolean(sender, args.get(0), group.inheritsPermission(args.get(0), true, args.get(1).toLowerCase()));
|
||||
} else {
|
||||
Util.sendBoolean(sender, args.get(0), group.inheritsPermission(args.get(0), true));
|
||||
+4
-3
@@ -10,15 +10,16 @@ import me.lucko.luckperms.groups.Group;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class GroupListNodesCommand extends GroupSubCommand {
|
||||
public GroupListNodesCommand() {
|
||||
public class GroupListNodes extends GroupSubCommand {
|
||||
public GroupListNodes() {
|
||||
super("listnodes", "Lists the permission nodes the group has", "/%s group <group> listnodes",
|
||||
Permission.GROUP_LISTNODES);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
|
||||
Message.LISTNODES.send(sender, group.getName(), Util.nodesToString(group.getNodes()));
|
||||
Message.LISTNODES.send(sender, group.getName(), Util.permNodesToString(group.getPermanentNodes()));
|
||||
Message.LISTNODES_TEMP.send(sender, group.getName(), Util.tempNodesToString(group.getTemporaryNodes()));
|
||||
}
|
||||
|
||||
@Override
|
||||
+13
-2
@@ -7,11 +7,12 @@ import me.lucko.luckperms.constants.Message;
|
||||
import me.lucko.luckperms.constants.Permission;
|
||||
import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
|
||||
import me.lucko.luckperms.groups.Group;
|
||||
import me.lucko.luckperms.utils.Patterns;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class GroupSetInheritCommand extends GroupSubCommand {
|
||||
public GroupSetInheritCommand() {
|
||||
public class GroupSetInherit extends GroupSubCommand {
|
||||
public GroupSetInherit() {
|
||||
super("setinherit", "Sets another group for this group to inherit permissions from",
|
||||
"/%s group <group> setinherit <group> [server]", Permission.GROUP_SETINHERIT);
|
||||
}
|
||||
@@ -20,6 +21,11 @@ public class GroupSetInheritCommand extends GroupSubCommand {
|
||||
protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
|
||||
String groupName = args.get(0).toLowerCase();
|
||||
|
||||
if (groupName.contains("/") || groupName.contains("$")) {
|
||||
sendUsage(sender, label);
|
||||
return;
|
||||
}
|
||||
|
||||
plugin.getDatastore().loadGroup(groupName, success -> {
|
||||
if (!success) {
|
||||
Message.GROUP_LOAD_ERROR.send(sender);
|
||||
@@ -27,6 +33,11 @@ public class GroupSetInheritCommand extends GroupSubCommand {
|
||||
try {
|
||||
if (args.size() == 2) {
|
||||
final String server = args.get(1).toLowerCase();
|
||||
if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
|
||||
Message.SERVER_INVALID_ENTRY.send(sender);
|
||||
return;
|
||||
}
|
||||
|
||||
group.setPermission("group." + groupName, true, server);
|
||||
Message.GROUP_SETINHERIT_SERVER_SUCCESS.send(sender, group.getName(), groupName, server);
|
||||
} else {
|
||||
+8
-3
@@ -11,8 +11,8 @@ import me.lucko.luckperms.utils.Patterns;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class GroupSetPermissionCommand extends GroupSubCommand {
|
||||
public GroupSetPermissionCommand() {
|
||||
public class GroupSetPermission extends GroupSubCommand {
|
||||
public GroupSetPermission() {
|
||||
super("set", "Sets a permission for a group", "/%s group <group> set <node> <true|false> [server]",
|
||||
Permission.GROUP_SETPERMISSION);
|
||||
}
|
||||
@@ -22,7 +22,7 @@ public class GroupSetPermissionCommand extends GroupSubCommand {
|
||||
String node = args.get(0);
|
||||
String bool = args.get(1).toLowerCase();
|
||||
|
||||
if (node.contains("/")) {
|
||||
if (node.contains("/") || node.contains("$")) {
|
||||
sendUsage(sender, label);
|
||||
return;
|
||||
}
|
||||
@@ -42,6 +42,11 @@ public class GroupSetPermissionCommand extends GroupSubCommand {
|
||||
try {
|
||||
if (args.size() == 3) {
|
||||
final String server = args.get(2).toLowerCase();
|
||||
if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
|
||||
Message.SERVER_INVALID_ENTRY.send(sender);
|
||||
return;
|
||||
}
|
||||
|
||||
group.setPermission(node, b, server);
|
||||
Message.SETPERMISSION_SERVER_SUCCESS.send(sender, node, bool, group.getName(), server);
|
||||
} else {
|
||||
+80
@@ -0,0 +1,80 @@
|
||||
package me.lucko.luckperms.commands.group.subcommands;
|
||||
|
||||
import me.lucko.luckperms.LuckPermsPlugin;
|
||||
import me.lucko.luckperms.commands.Sender;
|
||||
import me.lucko.luckperms.commands.group.GroupSubCommand;
|
||||
import me.lucko.luckperms.constants.Message;
|
||||
import me.lucko.luckperms.constants.Permission;
|
||||
import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
|
||||
import me.lucko.luckperms.groups.Group;
|
||||
import me.lucko.luckperms.utils.DateUtil;
|
||||
import me.lucko.luckperms.utils.Patterns;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class GroupSetTempInherit extends GroupSubCommand {
|
||||
public GroupSetTempInherit() {
|
||||
super("settempinherit", "Sets another group for this group to inherit permissions from temporarily",
|
||||
"/%s group <group> settempinherit <group> <duration> [server]", Permission.GROUP_SET_TEMP_INHERIT);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
|
||||
String groupName = args.get(0).toLowerCase();
|
||||
|
||||
if (groupName.contains("/") || groupName.contains("$")) {
|
||||
sendUsage(sender, label);
|
||||
return;
|
||||
}
|
||||
|
||||
long duration;
|
||||
try {
|
||||
duration = DateUtil.parseDateDiff(args.get(1), true);
|
||||
} catch (DateUtil.IllegalDateException e) {
|
||||
Message.ILLEGAL_DATE_ERROR.send(sender, args.get(1));
|
||||
return;
|
||||
}
|
||||
|
||||
if (DateUtil.shouldExpire(duration)) {
|
||||
Message.PAST_DATE_ERROR.send(sender);
|
||||
return;
|
||||
}
|
||||
|
||||
plugin.getDatastore().loadGroup(groupName, success -> {
|
||||
if (!success) {
|
||||
Message.GROUP_LOAD_ERROR.send(sender);
|
||||
} else {
|
||||
try {
|
||||
if (args.size() == 3) {
|
||||
final String server = args.get(2).toLowerCase();
|
||||
if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
|
||||
Message.SERVER_INVALID_ENTRY.send(sender);
|
||||
return;
|
||||
}
|
||||
|
||||
group.setPermission("group." + groupName, true, server, duration);
|
||||
Message.GROUP_SET_TEMP_INHERIT_SERVER_SUCCESS.send(sender, group.getName(), groupName, server,
|
||||
DateUtil.formatDateDiff(duration));
|
||||
} else {
|
||||
group.setPermission("group." + groupName, true, duration);
|
||||
Message.GROUP_SET_TEMP_INHERIT_SUCCESS.send(sender, group.getName(), groupName, DateUtil.formatDateDiff(duration));
|
||||
}
|
||||
|
||||
saveGroup(group, sender, plugin);
|
||||
} catch (ObjectAlreadyHasException e) {
|
||||
Message.GROUP_ALREADY_TEMP_INHERITS.send(sender, group.getName(), groupName);
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
|
||||
return getGroupTabComplete(args, plugin);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isArgLengthInvalid(int argLength) {
|
||||
return argLength != 2 && argLength != 3;
|
||||
}
|
||||
}
|
||||
+86
@@ -0,0 +1,86 @@
|
||||
package me.lucko.luckperms.commands.group.subcommands;
|
||||
|
||||
import me.lucko.luckperms.LuckPermsPlugin;
|
||||
import me.lucko.luckperms.commands.Sender;
|
||||
import me.lucko.luckperms.commands.group.GroupSubCommand;
|
||||
import me.lucko.luckperms.constants.Message;
|
||||
import me.lucko.luckperms.constants.Permission;
|
||||
import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
|
||||
import me.lucko.luckperms.groups.Group;
|
||||
import me.lucko.luckperms.utils.DateUtil;
|
||||
import me.lucko.luckperms.utils.Patterns;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class GroupSetTempPermission extends GroupSubCommand {
|
||||
public GroupSetTempPermission() {
|
||||
super("settemp", "Sets a temporary permission for a group", "/%s group <group> settemp <node> <true|false> <duration> [server]",
|
||||
Permission.GROUP_SET_TEMP_PERMISSION);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
|
||||
String node = args.get(0);
|
||||
String bool = args.get(1).toLowerCase();
|
||||
|
||||
if (node.contains("/") || node.contains("$")) {
|
||||
sendUsage(sender, label);
|
||||
return;
|
||||
}
|
||||
|
||||
if (Patterns.GROUP_MATCH.matcher(node).matches()) {
|
||||
Message.GROUP_USE_INHERIT.send(sender);
|
||||
return;
|
||||
}
|
||||
|
||||
if (!bool.equalsIgnoreCase("true") && !bool.equalsIgnoreCase("false")) {
|
||||
sendUsage(sender, label);
|
||||
return;
|
||||
}
|
||||
|
||||
boolean b = Boolean.parseBoolean(bool);
|
||||
|
||||
long duration;
|
||||
try {
|
||||
duration = DateUtil.parseDateDiff(args.get(2), true);
|
||||
} catch (DateUtil.IllegalDateException e) {
|
||||
Message.ILLEGAL_DATE_ERROR.send(sender, args.get(2));
|
||||
return;
|
||||
}
|
||||
|
||||
if (DateUtil.shouldExpire(duration)) {
|
||||
Message.PAST_DATE_ERROR.send(sender);
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
if (args.size() == 4) {
|
||||
final String server = args.get(3).toLowerCase();
|
||||
if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
|
||||
Message.SERVER_INVALID_ENTRY.send(sender);
|
||||
return;
|
||||
}
|
||||
|
||||
group.setPermission(node, b, server, duration);
|
||||
Message.SETPERMISSION_TEMP_SERVER_SUCCESS.send(sender, node, bool, group.getName(), server, DateUtil.formatDateDiff(duration));
|
||||
} else {
|
||||
group.setPermission(node, b, duration);
|
||||
Message.SETPERMISSION_TEMP_SUCCESS.send(sender, node, bool, group.getName(), DateUtil.formatDateDiff(duration));
|
||||
}
|
||||
|
||||
saveGroup(group, sender, plugin);
|
||||
} catch (ObjectAlreadyHasException e) {
|
||||
Message.ALREADY_HAS_TEMP_PERMISSION.send(sender, group.getName());
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
|
||||
return getBoolTabComplete(args);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isArgLengthInvalid(int argLength) {
|
||||
return argLength != 3 && argLength != 4;
|
||||
}
|
||||
}
|
||||
+2
-2
@@ -12,8 +12,8 @@ import me.lucko.luckperms.tracks.Track;
|
||||
import java.util.List;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
public class GroupShowTracksCommand extends GroupSubCommand {
|
||||
public GroupShowTracksCommand() {
|
||||
public class GroupShowTracks extends GroupSubCommand {
|
||||
public GroupShowTracks() {
|
||||
super("showtracks", "Lists the tracks that this group features on", "/%s group <group> showtracks", Permission.GROUP_SHOWTRACKS);
|
||||
}
|
||||
|
||||
+8
-3
@@ -11,8 +11,8 @@ import me.lucko.luckperms.utils.Patterns;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class GroupUnSetPermissionCommand extends GroupSubCommand {
|
||||
public GroupUnSetPermissionCommand() {
|
||||
public class GroupUnSetPermission extends GroupSubCommand {
|
||||
public GroupUnSetPermission() {
|
||||
super("unset", "Unsets a permission for a group",
|
||||
"/%s group <group> unset <node> [server]", Permission.GROUP_UNSETPERMISSION);
|
||||
}
|
||||
@@ -21,7 +21,7 @@ public class GroupUnSetPermissionCommand extends GroupSubCommand {
|
||||
protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
|
||||
String node = args.get(0);
|
||||
|
||||
if (node.contains("/")) {
|
||||
if (node.contains("/") || node.contains("$")) {
|
||||
sendUsage(sender, label);
|
||||
return;
|
||||
}
|
||||
@@ -34,6 +34,11 @@ public class GroupUnSetPermissionCommand extends GroupSubCommand {
|
||||
try {
|
||||
if (args.size() == 2) {
|
||||
final String server = args.get(1).toLowerCase();
|
||||
if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
|
||||
Message.SERVER_INVALID_ENTRY.send(sender);
|
||||
return;
|
||||
}
|
||||
|
||||
group.unsetPermission(node, server);
|
||||
Message.UNSETPERMISSION_SERVER_SUCCESS.send(sender, node, group.getName(), server);
|
||||
} else {
|
||||
+13
-2
@@ -7,11 +7,12 @@ import me.lucko.luckperms.constants.Message;
|
||||
import me.lucko.luckperms.constants.Permission;
|
||||
import me.lucko.luckperms.exceptions.ObjectLacksException;
|
||||
import me.lucko.luckperms.groups.Group;
|
||||
import me.lucko.luckperms.utils.Patterns;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class GroupUnsetInheritCommand extends GroupSubCommand {
|
||||
public GroupUnsetInheritCommand() {
|
||||
public class GroupUnsetInherit extends GroupSubCommand {
|
||||
public GroupUnsetInherit() {
|
||||
super("unsetinherit", "Unsets another group for this group to inherit permissions from",
|
||||
"/%s group <group> unsetinherit <group> [server]", Permission.GROUP_UNSETINHERIT);
|
||||
}
|
||||
@@ -20,9 +21,19 @@ public class GroupUnsetInheritCommand extends GroupSubCommand {
|
||||
protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
|
||||
String groupName = args.get(0).toLowerCase();
|
||||
|
||||
if (groupName.contains("/") || groupName.contains("$")) {
|
||||
sendUsage(sender, label);
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
if (args.size() == 2) {
|
||||
final String server = args.get(1).toLowerCase();
|
||||
if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
|
||||
Message.SERVER_INVALID_ENTRY.send(sender);
|
||||
return;
|
||||
}
|
||||
|
||||
group.unsetPermission("group." + groupName, server);
|
||||
Message.GROUP_UNSETINHERIT_SERVER_SUCCESS.send(sender, group.getName(), groupName, server);
|
||||
} else {
|
||||
+59
@@ -0,0 +1,59 @@
|
||||
package me.lucko.luckperms.commands.group.subcommands;
|
||||
|
||||
import me.lucko.luckperms.LuckPermsPlugin;
|
||||
import me.lucko.luckperms.commands.Sender;
|
||||
import me.lucko.luckperms.commands.group.GroupSubCommand;
|
||||
import me.lucko.luckperms.constants.Message;
|
||||
import me.lucko.luckperms.constants.Permission;
|
||||
import me.lucko.luckperms.exceptions.ObjectLacksException;
|
||||
import me.lucko.luckperms.groups.Group;
|
||||
import me.lucko.luckperms.utils.Patterns;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class GroupUnsetTempInherit extends GroupSubCommand {
|
||||
public GroupUnsetTempInherit() {
|
||||
super("unsettempinherit", "Unsets another group for this group to inherit permissions from",
|
||||
"/%s group <group> unsettempinherit <group> [server]", Permission.GROUP_UNSET_TEMP_INHERIT);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
|
||||
String groupName = args.get(0).toLowerCase();
|
||||
|
||||
if (groupName.contains("/") || groupName.contains("$")) {
|
||||
sendUsage(sender, label);
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
if (args.size() == 2) {
|
||||
final String server = args.get(1).toLowerCase();
|
||||
if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
|
||||
Message.SERVER_INVALID_ENTRY.send(sender);
|
||||
return;
|
||||
}
|
||||
|
||||
group.unsetPermission("group." + groupName, server, true);
|
||||
Message.GROUP_UNSET_TEMP_INHERIT_SERVER_SUCCESS.send(sender, group.getName(), groupName, server);
|
||||
} else {
|
||||
group.unsetPermission("group." + groupName, true);
|
||||
Message.GROUP_UNSET_TEMP_INHERIT_SUCCESS.send(sender, group.getName(), groupName);
|
||||
}
|
||||
|
||||
saveGroup(group, sender, plugin);
|
||||
} catch (ObjectLacksException e) {
|
||||
Message.GROUP_DOES_NOT_TEMP_INHERIT.send(sender, group.getName(), groupName);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
|
||||
return getGroupTabComplete(args, plugin);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isArgLengthInvalid(int argLength) {
|
||||
return argLength != 1 && argLength != 2;
|
||||
}
|
||||
}
|
||||
+59
@@ -0,0 +1,59 @@
|
||||
package me.lucko.luckperms.commands.group.subcommands;
|
||||
|
||||
import me.lucko.luckperms.LuckPermsPlugin;
|
||||
import me.lucko.luckperms.commands.Sender;
|
||||
import me.lucko.luckperms.commands.group.GroupSubCommand;
|
||||
import me.lucko.luckperms.constants.Message;
|
||||
import me.lucko.luckperms.constants.Permission;
|
||||
import me.lucko.luckperms.exceptions.ObjectLacksException;
|
||||
import me.lucko.luckperms.groups.Group;
|
||||
import me.lucko.luckperms.utils.Patterns;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class GroupUnsetTempPermission extends GroupSubCommand {
|
||||
public GroupUnsetTempPermission() {
|
||||
super("unsettemp", "Unsets a temporary permission for a group",
|
||||
"/%s group <group> unsettemp <node> [server]", Permission.GROUP_UNSET_TEMP_PERMISSION);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
|
||||
String node = args.get(0);
|
||||
|
||||
if (node.contains("/") || node.contains("$")) {
|
||||
sendUsage(sender, label);
|
||||
return;
|
||||
}
|
||||
|
||||
if (Patterns.GROUP_MATCH.matcher(node).matches()) {
|
||||
Message.GROUP_USE_UNINHERIT.send(sender);
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
if (args.size() == 2) {
|
||||
final String server = args.get(1).toLowerCase();
|
||||
if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
|
||||
Message.SERVER_INVALID_ENTRY.send(sender);
|
||||
return;
|
||||
}
|
||||
|
||||
group.unsetPermission(node, server);
|
||||
Message.UNSET_TEMP_PERMISSION_SERVER_SUCCESS.send(sender, node, group.getName(), server, true);
|
||||
} else {
|
||||
group.unsetPermission(node, true);
|
||||
Message.UNSET_TEMP_PERMISSION_SUCCESS.send(sender, node, group.getName());
|
||||
}
|
||||
|
||||
saveGroup(group, sender, plugin);
|
||||
} catch (ObjectLacksException e) {
|
||||
Message.DOES_NOT_HAVE_TEMP_PERMISSION.send(sender, group.getName());
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isArgLengthInvalid(int argLength) {
|
||||
return argLength != 1 && argLength != 2;
|
||||
}
|
||||
}
|
||||
@@ -6,6 +6,7 @@ import me.lucko.luckperms.commands.Sender;
|
||||
import me.lucko.luckperms.commands.SubCommand;
|
||||
import me.lucko.luckperms.constants.Message;
|
||||
import me.lucko.luckperms.constants.Permission;
|
||||
import me.lucko.luckperms.utils.LPConfiguration;
|
||||
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
@@ -17,7 +18,9 @@ public class InfoCommand extends MainCommand {
|
||||
|
||||
@Override
|
||||
protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
|
||||
Message.INFO.send(sender, plugin.getVersion(), plugin.getDatastore().getName());
|
||||
final LPConfiguration c = plugin.getConfiguration();
|
||||
Message.INFO.send(sender, plugin.getVersion(), plugin.getDatastore().getName(), c.getServer(),
|
||||
c.getDefaultGroupName(), c.getSyncTime(), c.getIncludeGlobalPerms());
|
||||
}
|
||||
|
||||
@Override
|
||||
|
||||
+2
-2
@@ -11,8 +11,8 @@ import me.lucko.luckperms.utils.Patterns;
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
|
||||
public class CreateTrackCommand extends MainCommand {
|
||||
public CreateTrackCommand() {
|
||||
public class CreateTrack extends MainCommand {
|
||||
public CreateTrack() {
|
||||
super("CreateTrack", "/%s createtrack <track>", 1);
|
||||
}
|
||||
|
||||
+8
-2
@@ -7,14 +7,15 @@ import me.lucko.luckperms.commands.SubCommand;
|
||||
import me.lucko.luckperms.constants.Message;
|
||||
import me.lucko.luckperms.constants.Permission;
|
||||
import me.lucko.luckperms.tracks.Track;
|
||||
import me.lucko.luckperms.utils.Patterns;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
public class DeleteTrackCommand extends MainCommand {
|
||||
public DeleteTrackCommand() {
|
||||
public class DeleteTrack extends MainCommand {
|
||||
public DeleteTrack() {
|
||||
super("DeleteTrack", "/%s deletetrack <track>", 1);
|
||||
}
|
||||
|
||||
@@ -27,6 +28,11 @@ public class DeleteTrackCommand extends MainCommand {
|
||||
|
||||
String trackName = args.get(0).toLowerCase();
|
||||
|
||||
if (Patterns.NON_ALPHA_NUMERIC.matcher(trackName).find()) {
|
||||
Message.TRACK_INVALID_ENTRY.send(sender);
|
||||
return;
|
||||
}
|
||||
|
||||
plugin.getDatastore().loadTrack(trackName, success -> {
|
||||
if (!success) {
|
||||
Message.TRACK_DOES_NOT_EXIST.send(sender);
|
||||
+2
-2
@@ -12,8 +12,8 @@ import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
|
||||
public class ListTracksCommand extends MainCommand {
|
||||
public ListTracksCommand() {
|
||||
public class ListTracks extends MainCommand {
|
||||
public ListTracks() {
|
||||
super("ListTracks", "/%s listtracks", 0);
|
||||
}
|
||||
|
||||
@@ -6,6 +6,7 @@ import me.lucko.luckperms.commands.Sender;
|
||||
import me.lucko.luckperms.commands.SubCommand;
|
||||
import me.lucko.luckperms.constants.Message;
|
||||
import me.lucko.luckperms.tracks.Track;
|
||||
import me.lucko.luckperms.utils.Patterns;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
@@ -51,6 +52,12 @@ public class TrackMainCommand extends MainCommand {
|
||||
}
|
||||
|
||||
final String trackName = args.get(0).toLowerCase();
|
||||
|
||||
if (Patterns.NON_ALPHA_NUMERIC.matcher(trackName).find()) {
|
||||
Message.TRACK_INVALID_ENTRY.send(sender);
|
||||
return;
|
||||
}
|
||||
|
||||
plugin.getDatastore().loadTrack(trackName, success -> {
|
||||
if (!success) {
|
||||
Message.TRACK_NOT_FOUND.send(sender);
|
||||
|
||||
+2
-2
@@ -12,8 +12,8 @@ import me.lucko.luckperms.tracks.Track;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class TrackAppendCommand extends TrackSubCommand {
|
||||
public TrackAppendCommand() {
|
||||
public class TrackAppend extends TrackSubCommand {
|
||||
public TrackAppend() {
|
||||
super("append", "Appends a group onto the end of the track", "/%s track <track> append <group>", Permission.TRACK_APPEND);
|
||||
}
|
||||
|
||||
+2
-2
@@ -9,8 +9,8 @@ import me.lucko.luckperms.tracks.Track;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class TrackClearCommand extends TrackSubCommand {
|
||||
public TrackClearCommand() {
|
||||
public class TrackClear extends TrackSubCommand {
|
||||
public TrackClear() {
|
||||
super("clear", "Clears the groups on the track", "/%s track <track> clear", Permission.TRACK_CLEAR);
|
||||
}
|
||||
|
||||
+2
-2
@@ -10,8 +10,8 @@ import me.lucko.luckperms.tracks.Track;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class TrackInfoCommand extends TrackSubCommand {
|
||||
public TrackInfoCommand() {
|
||||
public class TrackInfo extends TrackSubCommand {
|
||||
public TrackInfo() {
|
||||
super("info", "Gives info about the track", "/%s track <track> info", Permission.TRACK_INFO);
|
||||
}
|
||||
|
||||
+2
-2
@@ -12,8 +12,8 @@ import me.lucko.luckperms.tracks.Track;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class TrackInsertCommand extends TrackSubCommand {
|
||||
public TrackInsertCommand() {
|
||||
public class TrackInsert extends TrackSubCommand {
|
||||
public TrackInsert() {
|
||||
super("insert", "Inserts a group at a given position along the track",
|
||||
"/%s track <track> insert <group> <position>", Permission.TRACK_INSERT);
|
||||
}
|
||||
+2
-2
@@ -10,8 +10,8 @@ import me.lucko.luckperms.tracks.Track;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class TrackRemoveCommand extends TrackSubCommand {
|
||||
public TrackRemoveCommand() {
|
||||
public class TrackRemove extends TrackSubCommand {
|
||||
public TrackRemove() {
|
||||
super("remove", "Removes a group from the track", "/%s track <track> remove <group>", Permission.TRACK_REMOVE);
|
||||
}
|
||||
|
||||
@@ -7,6 +7,7 @@ import me.lucko.luckperms.commands.SubCommand;
|
||||
import me.lucko.luckperms.commands.Util;
|
||||
import me.lucko.luckperms.constants.Message;
|
||||
import me.lucko.luckperms.users.User;
|
||||
import me.lucko.luckperms.utils.Patterns;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
@@ -54,6 +55,12 @@ public class UserMainCommand extends MainCommand {
|
||||
}
|
||||
|
||||
final String user = args.get(0);
|
||||
|
||||
if (Patterns.NON_USERNAME.matcher(user).find()) {
|
||||
Message.USER_INVALID_ENTRY.send(sender, user);
|
||||
return;
|
||||
}
|
||||
|
||||
UUID u = Util.parseUuid(user);
|
||||
if (u != null) {
|
||||
runSub(plugin, sender, u, sub, strippedArgs, label);
|
||||
|
||||
+13
-2
@@ -8,11 +8,12 @@ import me.lucko.luckperms.constants.Permission;
|
||||
import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
|
||||
import me.lucko.luckperms.groups.Group;
|
||||
import me.lucko.luckperms.users.User;
|
||||
import me.lucko.luckperms.utils.Patterns;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class UserAddGroupCommand extends UserSubCommand {
|
||||
public UserAddGroupCommand() {
|
||||
public class UserAddGroup extends UserSubCommand {
|
||||
public UserAddGroup() {
|
||||
super("addgroup", "Adds the user to a group", "/%s user <user> addgroup <group> [server]", Permission.USER_ADDGROUP);
|
||||
}
|
||||
|
||||
@@ -20,6 +21,11 @@ public class UserAddGroupCommand extends UserSubCommand {
|
||||
protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
|
||||
String groupName = args.get(0).toLowerCase();
|
||||
|
||||
if (groupName.contains("/") || groupName.contains("$")) {
|
||||
sendUsage(sender, label);
|
||||
return;
|
||||
}
|
||||
|
||||
plugin.getDatastore().loadGroup(groupName, success -> {
|
||||
if (!success) {
|
||||
Message.GROUP_DOES_NOT_EXIST.send(sender);
|
||||
@@ -33,6 +39,11 @@ public class UserAddGroupCommand extends UserSubCommand {
|
||||
try {
|
||||
if (args.size() == 2) {
|
||||
final String server = args.get(1).toLowerCase();
|
||||
if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
|
||||
Message.SERVER_INVALID_ENTRY.send(sender);
|
||||
return;
|
||||
}
|
||||
|
||||
user.addGroup(group, server);
|
||||
Message.USER_ADDGROUP_SERVER_SUCCESS.send(sender, user.getName(), groupName, server);
|
||||
} else {
|
||||
+87
@@ -0,0 +1,87 @@
|
||||
package me.lucko.luckperms.commands.user.subcommands;
|
||||
|
||||
import me.lucko.luckperms.LuckPermsPlugin;
|
||||
import me.lucko.luckperms.commands.Sender;
|
||||
import me.lucko.luckperms.commands.user.UserSubCommand;
|
||||
import me.lucko.luckperms.constants.Message;
|
||||
import me.lucko.luckperms.constants.Permission;
|
||||
import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
|
||||
import me.lucko.luckperms.groups.Group;
|
||||
import me.lucko.luckperms.users.User;
|
||||
import me.lucko.luckperms.utils.DateUtil;
|
||||
import me.lucko.luckperms.utils.Patterns;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class UserAddTempGroup extends UserSubCommand {
|
||||
public UserAddTempGroup() {
|
||||
super("addtempgroup", "Adds the user to a group temporarily", "/%s user <user> addtempgroup <group> <duration> [server]",
|
||||
Permission.USER_ADDTEMPGROUP);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
|
||||
String groupName = args.get(0).toLowerCase();
|
||||
|
||||
if (groupName.contains("/") || groupName.contains("$")) {
|
||||
sendUsage(sender, label);
|
||||
return;
|
||||
}
|
||||
|
||||
long duration;
|
||||
try {
|
||||
duration = DateUtil.parseDateDiff(args.get(1), true);
|
||||
} catch (DateUtil.IllegalDateException e) {
|
||||
Message.ILLEGAL_DATE_ERROR.send(sender, args.get(1));
|
||||
return;
|
||||
}
|
||||
|
||||
if (DateUtil.shouldExpire(duration)) {
|
||||
Message.PAST_DATE_ERROR.send(sender);
|
||||
return;
|
||||
}
|
||||
|
||||
plugin.getDatastore().loadGroup(groupName, success -> {
|
||||
if (!success) {
|
||||
Message.GROUP_DOES_NOT_EXIST.send(sender);
|
||||
} else {
|
||||
Group group = plugin.getGroupManager().getGroup(groupName);
|
||||
if (group == null) {
|
||||
Message.GROUP_DOES_NOT_EXIST.send(sender);
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
if (args.size() == 3) {
|
||||
final String server = args.get(2).toLowerCase();
|
||||
if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
|
||||
Message.SERVER_INVALID_ENTRY.send(sender);
|
||||
return;
|
||||
}
|
||||
|
||||
user.addGroup(group, server, duration);
|
||||
Message.USER_ADDTEMPGROUP_SERVER_SUCCESS.send(sender, user.getName(), groupName, server,
|
||||
DateUtil.formatDateDiff(duration));
|
||||
} else {
|
||||
user.addGroup(group, duration);
|
||||
Message.USER_ADDTEMPGROUP_SUCCESS.send(sender, user.getName(), groupName, DateUtil.formatDateDiff(duration));
|
||||
}
|
||||
|
||||
saveUser(user, sender, plugin);
|
||||
} catch (ObjectAlreadyHasException e) {
|
||||
Message.USER_ALREADY_TEMP_MEMBER_OF.send(sender, user.getName(), group.getName());
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
|
||||
return getGroupTabComplete(args, plugin);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isArgLengthInvalid(int argLength) {
|
||||
return (argLength != 2 && argLength != 3);
|
||||
}
|
||||
}
|
||||
+2
-2
@@ -9,8 +9,8 @@ import me.lucko.luckperms.users.User;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class UserClearCommand extends UserSubCommand {
|
||||
public UserClearCommand() {
|
||||
public class UserClear extends UserSubCommand {
|
||||
public UserClear() {
|
||||
super("clear", "Clears a users permissions and groups", "/%s user <user> clear", Permission.USER_CLEAR);
|
||||
}
|
||||
|
||||
+6
-4
@@ -14,8 +14,8 @@ import me.lucko.luckperms.users.User;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class UserDemoteCommand extends UserSubCommand {
|
||||
public UserDemoteCommand() {
|
||||
public class UserDemote extends UserSubCommand {
|
||||
public UserDemote() {
|
||||
super("demote", "Demotes a user along a track", "/%s user <user> demote <track>", Permission.USER_DEMOTE);
|
||||
}
|
||||
|
||||
@@ -65,9 +65,11 @@ public class UserDemoteCommand extends UserSubCommand {
|
||||
|
||||
try {
|
||||
user.unsetPermission("group." + old);
|
||||
} catch (ObjectLacksException ignored) {}
|
||||
try {
|
||||
user.addGroup(previousGroup);
|
||||
user.setPrimaryGroup(previousGroup.getName());
|
||||
} catch (ObjectLacksException | ObjectAlreadyHasException ignored) {}
|
||||
} catch (ObjectAlreadyHasException ignored) {}
|
||||
user.setPrimaryGroup(previousGroup.getName());
|
||||
|
||||
Message.USER_DEMOTE_SUCCESS_PROMOTE.send(sender, track.getName(), old, previousGroup.getName());
|
||||
Message.USER_DEMOTE_SUCCESS_REMOVE.send(sender, user.getName(), old, previousGroup.getName(), previousGroup.getName());
|
||||
+2
-2
@@ -9,8 +9,8 @@ import me.lucko.luckperms.users.User;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class UserGetUUIDCommand extends UserSubCommand {
|
||||
public UserGetUUIDCommand() {
|
||||
public class UserGetUUID extends UserSubCommand {
|
||||
public UserGetUUID() {
|
||||
super("getuuid", "Get the UUID of a user", "/%s user <user> getuuid", Permission.USER_GETUUID);
|
||||
}
|
||||
|
||||
+9
-2
@@ -4,13 +4,15 @@ import me.lucko.luckperms.LuckPermsPlugin;
|
||||
import me.lucko.luckperms.commands.Sender;
|
||||
import me.lucko.luckperms.commands.Util;
|
||||
import me.lucko.luckperms.commands.user.UserSubCommand;
|
||||
import me.lucko.luckperms.constants.Message;
|
||||
import me.lucko.luckperms.constants.Permission;
|
||||
import me.lucko.luckperms.users.User;
|
||||
import me.lucko.luckperms.utils.Patterns;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class UserHasPermCommand extends UserSubCommand {
|
||||
public UserHasPermCommand() {
|
||||
public class UserHasPerm extends UserSubCommand {
|
||||
public UserHasPerm() {
|
||||
super("haspermission", "Checks to see if a user has a certain permission node",
|
||||
"/%s user <user> haspermission <node> [server]", Permission.USER_HASPERMISSION);
|
||||
}
|
||||
@@ -18,6 +20,11 @@ public class UserHasPermCommand extends UserSubCommand {
|
||||
@Override
|
||||
protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
|
||||
if (args.size() >= 2) {
|
||||
if (Patterns.NON_ALPHA_NUMERIC.matcher(args.get(1)).find()) {
|
||||
Message.SERVER_INVALID_ENTRY.send(sender);
|
||||
return;
|
||||
}
|
||||
|
||||
Util.sendBoolean(sender, args.get(0), user.hasPermission(args.get(0), true, args.get(1)));
|
||||
} else {
|
||||
Util.sendBoolean(sender, args.get(0), user.hasPermission(args.get(0), true, "global"));
|
||||
+3
-3
@@ -10,8 +10,8 @@ import me.lucko.luckperms.users.User;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class UserInfoCommand extends UserSubCommand {
|
||||
public UserInfoCommand() {
|
||||
public class UserInfo extends UserSubCommand {
|
||||
public UserInfo() {
|
||||
super("info", "Gives info about the user", "/%s user <user> info", Permission.USER_INFO);
|
||||
}
|
||||
|
||||
@@ -19,7 +19,7 @@ public class UserInfoCommand extends UserSubCommand {
|
||||
protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
|
||||
Message.USER_INFO.send(sender, user.getName(), user.getUuid(), plugin.getPlayerStatus(user.getUuid()),
|
||||
Util.listToCommaSep(user.getGroupNames()), user.getPrimaryGroup(),
|
||||
(user.getNodes().keySet().size() - user.getGroupNames().size()), label, user.getName()
|
||||
user.getPermanentNodes().keySet().size(), user.getTemporaryNodes().keySet().size(), label, user.getName()
|
||||
);
|
||||
}
|
||||
|
||||
+9
-2
@@ -4,13 +4,15 @@ import me.lucko.luckperms.LuckPermsPlugin;
|
||||
import me.lucko.luckperms.commands.Sender;
|
||||
import me.lucko.luckperms.commands.Util;
|
||||
import me.lucko.luckperms.commands.user.UserSubCommand;
|
||||
import me.lucko.luckperms.constants.Message;
|
||||
import me.lucko.luckperms.constants.Permission;
|
||||
import me.lucko.luckperms.users.User;
|
||||
import me.lucko.luckperms.utils.Patterns;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class UserInheritsPermCommand extends UserSubCommand {
|
||||
public UserInheritsPermCommand() {
|
||||
public class UserInheritsPerm extends UserSubCommand {
|
||||
public UserInheritsPerm() {
|
||||
super("inheritspermission", "Checks to see if a user inherits a certain permission node",
|
||||
"/%s user <user> inheritspermission <node> [server]", Permission.USER_INHERITSPERMISSION);
|
||||
}
|
||||
@@ -18,6 +20,11 @@ public class UserInheritsPermCommand extends UserSubCommand {
|
||||
@Override
|
||||
protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
|
||||
if (args.size() >= 2) {
|
||||
if (Patterns.NON_ALPHA_NUMERIC.matcher(args.get(1)).find()) {
|
||||
Message.SERVER_INVALID_ENTRY.send(sender);
|
||||
return;
|
||||
}
|
||||
|
||||
Util.sendBoolean(sender, args.get(0), user.inheritsPermission(args.get(0), true, args.get(1)));
|
||||
} else {
|
||||
Util.sendBoolean(sender, args.get(0), user.inheritsPermission(args.get(0), true));
|
||||
+4
-3
@@ -10,14 +10,15 @@ import me.lucko.luckperms.users.User;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class UserListNodesCommand extends UserSubCommand {
|
||||
public UserListNodesCommand() {
|
||||
public class UserListNodes extends UserSubCommand {
|
||||
public UserListNodes() {
|
||||
super("listnodes", "Lists the permission nodes the user has", "/%s user <user> listnodes", Permission.USER_LISTNODES);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
|
||||
Message.LISTNODES.send(sender, user.getName(), Util.nodesToString(user.getNodes()));
|
||||
Message.LISTNODES.send(sender, user.getName(), Util.permNodesToString(user.getPermanentNodes()));
|
||||
Message.LISTNODES_TEMP.send(sender, user.getName(), Util.tempNodesToString(user.getTemporaryNodes()));
|
||||
}
|
||||
|
||||
@Override
|
||||
+6
-4
@@ -14,8 +14,8 @@ import me.lucko.luckperms.users.User;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class UserPromoteCommand extends UserSubCommand {
|
||||
public UserPromoteCommand() {
|
||||
public class UserPromote extends UserSubCommand {
|
||||
public UserPromote() {
|
||||
super("promote", "Promotes the user along a track", "/%s user <user> promote <track>", Permission.USER_PROMOTE);
|
||||
}
|
||||
|
||||
@@ -65,9 +65,11 @@ public class UserPromoteCommand extends UserSubCommand {
|
||||
|
||||
try {
|
||||
user.unsetPermission("group." + old);
|
||||
} catch (ObjectLacksException ignored) {}
|
||||
try {
|
||||
user.addGroup(nextGroup);
|
||||
user.setPrimaryGroup(nextGroup.getName());
|
||||
} catch (ObjectLacksException | ObjectAlreadyHasException ignored) {}
|
||||
} catch (ObjectAlreadyHasException ignored) {}
|
||||
user.setPrimaryGroup(nextGroup.getName());
|
||||
|
||||
Message.USER_PROMOTE_SUCCESS_PROMOTE.send(sender, track.getName(), old, nextGroup.getName());
|
||||
Message.USER_PROMOTE_SUCCESS_REMOVE.send(sender, user.getName(), old, nextGroup.getName(), nextGroup.getName());
|
||||
+13
-2
@@ -7,11 +7,12 @@ import me.lucko.luckperms.constants.Message;
|
||||
import me.lucko.luckperms.constants.Permission;
|
||||
import me.lucko.luckperms.exceptions.ObjectLacksException;
|
||||
import me.lucko.luckperms.users.User;
|
||||
import me.lucko.luckperms.utils.Patterns;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class UserRemoveGroupCommand extends UserSubCommand {
|
||||
public UserRemoveGroupCommand() {
|
||||
public class UserRemoveGroup extends UserSubCommand {
|
||||
public UserRemoveGroup() {
|
||||
super("removegroup", "Removes a user from a group", "/%s user <user> removegroup <group> [server]", Permission.USER_REMOVEGROUP);
|
||||
}
|
||||
|
||||
@@ -19,6 +20,11 @@ public class UserRemoveGroupCommand extends UserSubCommand {
|
||||
protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
|
||||
String groupName = args.get(0).toLowerCase();
|
||||
|
||||
if (groupName.contains("/") || groupName.contains("$")) {
|
||||
sendUsage(sender, label);
|
||||
return;
|
||||
}
|
||||
|
||||
if ((args.size() == 1 || (args.size() == 2 && args.get(1).equalsIgnoreCase("global")))
|
||||
&& user.getPrimaryGroup().equalsIgnoreCase(groupName)) {
|
||||
Message.USER_REMOVEGROUP_ERROR_PRIMARY.send(sender);
|
||||
@@ -28,6 +34,11 @@ public class UserRemoveGroupCommand extends UserSubCommand {
|
||||
try {
|
||||
if (args.size() == 2) {
|
||||
final String server = args.get(1).toLowerCase();
|
||||
if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
|
||||
Message.SERVER_INVALID_ENTRY.send(sender);
|
||||
return;
|
||||
}
|
||||
|
||||
user.unsetPermission("group." + groupName, server);
|
||||
Message.USER_REMOVEGROUP_SERVER_SUCCESS.send(sender, user.getName(), groupName, server);
|
||||
} else {
|
||||
+58
@@ -0,0 +1,58 @@
|
||||
package me.lucko.luckperms.commands.user.subcommands;
|
||||
|
||||
import me.lucko.luckperms.LuckPermsPlugin;
|
||||
import me.lucko.luckperms.commands.Sender;
|
||||
import me.lucko.luckperms.commands.user.UserSubCommand;
|
||||
import me.lucko.luckperms.constants.Message;
|
||||
import me.lucko.luckperms.constants.Permission;
|
||||
import me.lucko.luckperms.exceptions.ObjectLacksException;
|
||||
import me.lucko.luckperms.users.User;
|
||||
import me.lucko.luckperms.utils.Patterns;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class UserRemoveTempGroup extends UserSubCommand {
|
||||
public UserRemoveTempGroup() {
|
||||
super("removetempgroup", "Removes a user from a temporary group", "/%s user <user> removetempgroup <group> [server]", Permission.USER_REMOVETEMPGROUP);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
|
||||
String groupName = args.get(0).toLowerCase();
|
||||
|
||||
if (groupName.contains("/") || groupName.contains("$")) {
|
||||
sendUsage(sender, label);
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
if (args.size() == 2) {
|
||||
final String server = args.get(1).toLowerCase();
|
||||
if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
|
||||
Message.SERVER_INVALID_ENTRY.send(sender);
|
||||
return;
|
||||
}
|
||||
|
||||
user.unsetPermission("group." + groupName, server, true);
|
||||
Message.USER_REMOVETEMPGROUP_SERVER_SUCCESS.send(sender, user.getName(), groupName, server);
|
||||
} else {
|
||||
user.unsetPermission("group." + groupName, true);
|
||||
Message.USER_REMOVETEMPGROUP_SUCCESS.send(sender, user.getName(), groupName);
|
||||
}
|
||||
|
||||
saveUser(user, sender, plugin);
|
||||
} catch (ObjectLacksException e) {
|
||||
Message.USER_NOT_TEMP_MEMBER_OF.send(sender, user.getName(), groupName);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
|
||||
return getGroupTabComplete(args, plugin);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isArgLengthInvalid(int argLength) {
|
||||
return (argLength != 1 && argLength != 2);
|
||||
}
|
||||
}
|
||||
+8
-3
@@ -11,8 +11,8 @@ import me.lucko.luckperms.utils.Patterns;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class UserSetPermissionCommand extends UserSubCommand {
|
||||
public UserSetPermissionCommand() {
|
||||
public class UserSetPermission extends UserSubCommand {
|
||||
public UserSetPermission() {
|
||||
super("set", "Sets a permission for a user",
|
||||
"/%s user <user> set <node> <true|false> [server]", Permission.USER_SETPERMISSION);
|
||||
}
|
||||
@@ -22,7 +22,7 @@ public class UserSetPermissionCommand extends UserSubCommand {
|
||||
String node = args.get(0);
|
||||
String bool = args.get(1).toLowerCase();
|
||||
|
||||
if (node.contains("/")) {
|
||||
if (node.contains("/") || node.contains("$")) {
|
||||
sendUsage(sender, label);
|
||||
return;
|
||||
}
|
||||
@@ -42,6 +42,11 @@ public class UserSetPermissionCommand extends UserSubCommand {
|
||||
try {
|
||||
if (args.size() == 3) {
|
||||
final String server = args.get(2).toLowerCase();
|
||||
if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
|
||||
Message.SERVER_INVALID_ENTRY.send(sender);
|
||||
return;
|
||||
}
|
||||
|
||||
user.setPermission(node, b, server);
|
||||
Message.SETPERMISSION_SERVER_SUCCESS.send(sender, node, bool, user.getName(), server);
|
||||
} else {
|
||||
+2
-2
@@ -10,8 +10,8 @@ import me.lucko.luckperms.users.User;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class UserSetPrimaryGroupCommand extends UserSubCommand {
|
||||
public UserSetPrimaryGroupCommand() {
|
||||
public class UserSetPrimaryGroup extends UserSubCommand {
|
||||
public UserSetPrimaryGroup() {
|
||||
super("setprimarygroup", "Sets a users primary group",
|
||||
"/%s user <user> setprimarygroup <group>", Permission.USER_SETPRIMARYGROUP);
|
||||
}
|
||||
+86
@@ -0,0 +1,86 @@
|
||||
package me.lucko.luckperms.commands.user.subcommands;
|
||||
|
||||
import me.lucko.luckperms.LuckPermsPlugin;
|
||||
import me.lucko.luckperms.commands.Sender;
|
||||
import me.lucko.luckperms.commands.user.UserSubCommand;
|
||||
import me.lucko.luckperms.constants.Message;
|
||||
import me.lucko.luckperms.constants.Permission;
|
||||
import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
|
||||
import me.lucko.luckperms.users.User;
|
||||
import me.lucko.luckperms.utils.DateUtil;
|
||||
import me.lucko.luckperms.utils.Patterns;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class UserSetTempPermission extends UserSubCommand {
|
||||
public UserSetTempPermission() {
|
||||
super("settemp", "Sets a temporary permission for a user",
|
||||
"/%s user <user> settemp <node> <true|false> <duration> [server]", Permission.USER_SET_TEMP_PERMISSION);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
|
||||
String node = args.get(0);
|
||||
String bool = args.get(1).toLowerCase();
|
||||
|
||||
if (node.contains("/") || node.contains("$")) {
|
||||
sendUsage(sender, label);
|
||||
return;
|
||||
}
|
||||
|
||||
if (Patterns.GROUP_MATCH.matcher(node).matches()) {
|
||||
Message.USER_USE_ADDGROUP.send(sender);
|
||||
return;
|
||||
}
|
||||
|
||||
if (!bool.equalsIgnoreCase("true") && !bool.equalsIgnoreCase("false")) {
|
||||
sendUsage(sender, label);
|
||||
return;
|
||||
}
|
||||
|
||||
boolean b = Boolean.parseBoolean(bool);
|
||||
|
||||
long duration;
|
||||
try {
|
||||
duration = DateUtil.parseDateDiff(args.get(2), true);
|
||||
} catch (DateUtil.IllegalDateException e) {
|
||||
Message.ILLEGAL_DATE_ERROR.send(sender, args.get(2));
|
||||
return;
|
||||
}
|
||||
|
||||
if (DateUtil.shouldExpire(duration)) {
|
||||
Message.PAST_DATE_ERROR.send(sender);
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
if (args.size() == 4) {
|
||||
final String server = args.get(3).toLowerCase();
|
||||
if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
|
||||
Message.SERVER_INVALID_ENTRY.send(sender);
|
||||
return;
|
||||
}
|
||||
|
||||
user.setPermission(node, b, server, duration);
|
||||
Message.SETPERMISSION_TEMP_SERVER_SUCCESS.send(sender, node, bool, user.getName(), server, DateUtil.formatDateDiff(duration));
|
||||
} else {
|
||||
user.setPermission(node, b, duration);
|
||||
Message.SETPERMISSION_TEMP_SUCCESS.send(sender, node, bool, user.getName(), DateUtil.formatDateDiff(duration));
|
||||
}
|
||||
|
||||
saveUser(user, sender, plugin);
|
||||
} catch (ObjectAlreadyHasException e) {
|
||||
Message.ALREADY_HAS_TEMP_PERMISSION.send(sender, user.getName());
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
|
||||
return getBoolTabComplete(args);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isArgLengthInvalid(int argLength) {
|
||||
return argLength != 3 && argLength != 4;
|
||||
}
|
||||
}
|
||||
+2
-2
@@ -11,8 +11,8 @@ import me.lucko.luckperms.users.User;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class UserShowPosCommand extends UserSubCommand {
|
||||
public UserShowPosCommand() {
|
||||
public class UserShowPos extends UserSubCommand {
|
||||
public UserShowPos() {
|
||||
super("showpos", "Shows a users position on a track", "/%s user <user> showpos <track>", Permission.USER_SHOWPOS);
|
||||
}
|
||||
|
||||
+2
-2
@@ -12,8 +12,8 @@ import me.lucko.luckperms.users.User;
|
||||
import java.util.List;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
public class UserShowTracksCommand extends UserSubCommand {
|
||||
public UserShowTracksCommand() {
|
||||
public class UserShowTracks extends UserSubCommand {
|
||||
public UserShowTracks() {
|
||||
super("showtracks", "Lists the tracks that this user's primary group features on", "/%s user <user> showtracks",
|
||||
Permission.USER_SHOWTRACKS);
|
||||
}
|
||||
+8
-3
@@ -11,8 +11,8 @@ import me.lucko.luckperms.utils.Patterns;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class UserUnSetPermissionCommand extends UserSubCommand {
|
||||
public UserUnSetPermissionCommand() {
|
||||
public class UserUnSetPermission extends UserSubCommand {
|
||||
public UserUnSetPermission() {
|
||||
super("unset", "Unsets a permission for a user",
|
||||
"/%s user <user> unset <node> [server]", Permission.USER_UNSETPERMISSION);
|
||||
}
|
||||
@@ -21,7 +21,7 @@ public class UserUnSetPermissionCommand extends UserSubCommand {
|
||||
protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
|
||||
String node = args.get(0);
|
||||
|
||||
if (node.contains("/")) {
|
||||
if (node.contains("/") || node.contains("$")) {
|
||||
sendUsage(sender, label);
|
||||
return;
|
||||
}
|
||||
@@ -34,6 +34,11 @@ public class UserUnSetPermissionCommand extends UserSubCommand {
|
||||
try {
|
||||
if (args.size() == 2) {
|
||||
final String server = args.get(1).toLowerCase();
|
||||
if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
|
||||
Message.SERVER_INVALID_ENTRY.send(sender);
|
||||
return;
|
||||
}
|
||||
|
||||
user.unsetPermission(node, server);
|
||||
Message.UNSETPERMISSION_SERVER_SUCCESS.send(sender, node, user.getName(), server);
|
||||
} else {
|
||||
+59
@@ -0,0 +1,59 @@
|
||||
package me.lucko.luckperms.commands.user.subcommands;
|
||||
|
||||
import me.lucko.luckperms.LuckPermsPlugin;
|
||||
import me.lucko.luckperms.commands.Sender;
|
||||
import me.lucko.luckperms.commands.user.UserSubCommand;
|
||||
import me.lucko.luckperms.constants.Message;
|
||||
import me.lucko.luckperms.constants.Permission;
|
||||
import me.lucko.luckperms.exceptions.ObjectLacksException;
|
||||
import me.lucko.luckperms.users.User;
|
||||
import me.lucko.luckperms.utils.Patterns;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class UserUnsetTempPermission extends UserSubCommand {
|
||||
public UserUnsetTempPermission() {
|
||||
super("unsettemp", "Unsets a temporary permission for a user",
|
||||
"/%s user <user> unsettemp <node> [server]", Permission.USER_UNSET_TEMP_PERMISSION);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
|
||||
String node = args.get(0);
|
||||
|
||||
if (node.contains("/") || node.contains("$")) {
|
||||
sendUsage(sender, label);
|
||||
return;
|
||||
}
|
||||
|
||||
if (Patterns.GROUP_MATCH.matcher(node).matches()) {
|
||||
Message.USER_USE_REMOVEGROUP.send(sender);
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
if (args.size() == 2) {
|
||||
final String server = args.get(1).toLowerCase();
|
||||
if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
|
||||
Message.SERVER_INVALID_ENTRY.send(sender);
|
||||
return;
|
||||
}
|
||||
|
||||
user.unsetPermission(node, server, true);
|
||||
Message.UNSET_TEMP_PERMISSION_SERVER_SUCCESS.send(sender, node, user.getName(), server);
|
||||
} else {
|
||||
user.unsetPermission(node, true);
|
||||
Message.UNSET_TEMP_PERMISSION_SUCCESS.send(sender, node, user.getName());
|
||||
}
|
||||
|
||||
saveUser(user, sender, plugin);
|
||||
} catch (ObjectLacksException e) {
|
||||
Message.DOES_NOT_HAVE_TEMP_PERMISSION.send(sender, user.getName());
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isArgLengthInvalid(int argLength) {
|
||||
return argLength != 1 && argLength != 2;
|
||||
}
|
||||
}
|
||||
@@ -20,6 +20,8 @@ public enum Message {
|
||||
|
||||
ALREADY_HASPERMISSION("%s already has this permission!", true),
|
||||
DOES_NOT_HAVEPERMISSION("%s does not have this permission set.", true),
|
||||
ALREADY_HAS_TEMP_PERMISSION("%s already has this permission set temporarily!", true),
|
||||
DOES_NOT_HAVE_TEMP_PERMISSION("%s does not have this permission set temporarily.", true),
|
||||
|
||||
|
||||
|
||||
@@ -50,9 +52,11 @@ public enum Message {
|
||||
|
||||
GROUP_USE_INHERIT("Use the setinherit command instead of specifying the node.", true),
|
||||
GROUP_USE_UNINHERIT("Use the unsetinherit command instead of specifying the node.", true),
|
||||
GROUP_INVALID_ENTRY("Group names can only contain alphanumeric charcters.", true),
|
||||
GROUP_INVALID_ENTRY("Group names can only contain alphanumeric characters.", true),
|
||||
|
||||
TRACK_INVALID_ENTRY("Track names can only contain alphanumeric charcters.", true),
|
||||
TRACK_INVALID_ENTRY("Track names can only contain alphanumeric characters.", true),
|
||||
|
||||
SERVER_INVALID_ENTRY("Server names can only contain alphanumeric characters.", true),
|
||||
|
||||
|
||||
/**
|
||||
@@ -65,6 +69,12 @@ public enum Message {
|
||||
USER_NOT_MEMBER_OF("%s is not a member of '%s'.", true),
|
||||
GROUP_ALREADY_INHERITS("%s already inherits '%s'.", true),
|
||||
GROUP_DOES_NOT_INHERIT("%s does not inherit '%s'.", true),
|
||||
|
||||
USER_ALREADY_TEMP_MEMBER_OF("%s is already a temporary member of '%s'.", true),
|
||||
USER_NOT_TEMP_MEMBER_OF("%s is not a temporary member of '%s'.", true),
|
||||
GROUP_ALREADY_TEMP_INHERITS("%s already temporarily inherits '%s'.", true),
|
||||
GROUP_DOES_NOT_TEMP_INHERIT("%s does not temporarily inherit '%s'.", true),
|
||||
|
||||
TRACK_ALREADY_CONTAINS("Track %s already contains the group '%s'.", true),
|
||||
TRACK_DOES_NOT_CONTAIN("Track %s does not contain the group '%s'.", true),
|
||||
|
||||
@@ -85,7 +95,11 @@ public enum Message {
|
||||
INFO(
|
||||
PREFIX + "&6Running &bLuckPerms %s&6." + "\n" +
|
||||
PREFIX + "&eAuthor: &6Luck" + "\n" +
|
||||
PREFIX + "&eStorage Method: &6%s",
|
||||
PREFIX + "&eStorage Method: &6%s" + "\n" +
|
||||
PREFIX + "&eServer Name: &6%s" + "\n" +
|
||||
PREFIX + "&eDefault Group: &6%s" + "\n" +
|
||||
PREFIX + "&eSync Interval: &6%s minutes" + "\n" +
|
||||
PREFIX + "&eInclude Global Perms: &6%s",
|
||||
false
|
||||
),
|
||||
DEBUG(
|
||||
@@ -107,11 +121,18 @@ public enum Message {
|
||||
TRACKS_LIST("&aTracks: %s", true),
|
||||
|
||||
LISTNODES("&e%s's Nodes:" + "\n" + "%s", true),
|
||||
LISTNODES_TEMP("&e%s's Temporary Nodes:" + "\n" + "%s", true),
|
||||
SETPERMISSION_SUCCESS("&aSet &b%s&a to &b%s&a for &b%s&a.", true),
|
||||
SETPERMISSION_SERVER_SUCCESS("&aSet &b%s&a to &b%s&a for &b%s&a on server &b%s&a.", true),
|
||||
SETPERMISSION_TEMP_SUCCESS("&aSet &b%s&a to &b%s&a for &b%s&a for a duration of &b%s&a.", true),
|
||||
SETPERMISSION_TEMP_SERVER_SUCCESS("&aSet &b%s&a to &b%s&a for &b%s&a on server &b%s&a for a duration of &b%s&a.", true),
|
||||
UNSETPERMISSION_SUCCESS("&aUnset &b%s&a for &b%s&a.", true),
|
||||
UNSETPERMISSION_SERVER_SUCCESS("&aUnset &b%s&a for &b%s&a on server &b%$s&a.", true),
|
||||
UNSET_TEMP_PERMISSION_SUCCESS("&aUnset temporary permission &b%s&a for &b%s&a.", true),
|
||||
UNSET_TEMP_PERMISSION_SERVER_SUCCESS("&aUnset temporary permission &b%s&a for &b%s&a on server &b%$s&a.", true),
|
||||
CLEAR_SUCCESS("&b%s&a's permissions were cleared.", true),
|
||||
ILLEGAL_DATE_ERROR("Could not parse date '%s'.", true),
|
||||
PAST_DATE_ERROR("You cannot set a date in the past!", true),
|
||||
|
||||
USER_INFO(
|
||||
PREFIX + "&d-> &eUser: &6%s" + "\n" +
|
||||
@@ -120,14 +141,19 @@ public enum Message {
|
||||
PREFIX + "&d-> &eGroups: &6%s" + "\n" +
|
||||
PREFIX + "&d-> &ePrimary Group: &6%s" + "\n" +
|
||||
PREFIX + "&d-> &ePermissions: &6%s" + "\n" +
|
||||
PREFIX + "&d-> &eTemporary Permissions: &6%s" + "\n" +
|
||||
PREFIX + "&d-> &bUse &a/%s user %s listnodes &bto see all permissions.",
|
||||
false
|
||||
),
|
||||
USER_GETUUID("&bThe UUID of &e%s&b is &e%s&b.", true),
|
||||
USER_ADDGROUP_SUCCESS("&b%s&a successfully added to group &b%s&a.", true),
|
||||
USER_ADDGROUP_SERVER_SUCCESS("&b%s&a successfully added to group &b%s&a on server &b%s&a.", true),
|
||||
USER_ADDTEMPGROUP_SUCCESS("&b%s&a successfully added to group &b%s&a for a duration of &b%s&a.", true),
|
||||
USER_ADDTEMPGROUP_SERVER_SUCCESS("&b%s&a successfully added to group &b%s&a on server &b%s&a for a duration of &b%s&a.", true),
|
||||
USER_REMOVEGROUP_SUCCESS("&b%s&a was removed from group &b%s&a.", true),
|
||||
USER_REMOVEGROUP_SERVER_SUCCESS("&b%s&a was removed from group &b%s&a on server &b%s&a.", true),
|
||||
USER_REMOVETEMPGROUP_SUCCESS("&b%s&a was removed from temproary group &b%s&a.", true),
|
||||
USER_REMOVETEMPGROUP_SERVER_SUCCESS("&b%s&a was removed from temporary group &b%s&a on server &b%s&a.", true),
|
||||
USER_REMOVEGROUP_ERROR_PRIMARY("You cannot remove a user from their primary group.", true),
|
||||
USER_PRIMARYGROUP_SUCCESS("&b%s&a's primary group was set to &b%s&a.", true),
|
||||
USER_PRIMARYGROUP_ERROR_ALREADYHAS("The user already has this group set as their primary group.", true),
|
||||
@@ -156,13 +182,18 @@ public enum Message {
|
||||
GROUP_INFO(
|
||||
PREFIX + "&d-> &eGroup: &6%s" + "\n" +
|
||||
PREFIX + "&d-> &ePermissions: &6%s" + "\n" +
|
||||
PREFIX + "&d-> &eTemporary Permissions: &6%s" + "\n" +
|
||||
PREFIX + "&d-> &bUse &a/%s group %s listnodes &bto see all permissions.",
|
||||
false
|
||||
),
|
||||
GROUP_SETINHERIT_SUCCESS("&b%s&a now inherits permissions from &b%s&a.", true),
|
||||
GROUP_SETINHERIT_SERVER_SUCCESS("&b%s&a now inherits permissions from &b%s&a on server &b%s&a.", true),
|
||||
GROUP_SET_TEMP_INHERIT_SUCCESS("&b%s&a now inherits permissions from &b%s&a for a duration of &b%s&a.", true),
|
||||
GROUP_SET_TEMP_INHERIT_SERVER_SUCCESS("&b%s&a now inherits permissions from &b%s&a on server &b%s&a for a duration of &b%s&a.", true),
|
||||
GROUP_UNSETINHERIT_SUCCESS("&b%s&a no longer inherits permissions from &b%s&a.", true),
|
||||
GROUP_UNSETINHERIT_SERVER_SUCCESS("&b%s&a no longer inherits permissions from &b%s&a on server &b%s&a.", true),
|
||||
GROUP_UNSET_TEMP_INHERIT_SUCCESS("&b%s&a no longer temporarily inherits permissions from &b%s&a.", true),
|
||||
GROUP_UNSET_TEMP_INHERIT_SERVER_SUCCESS("&b%s&a no longer temporarily inherits permissions from &b%s&a on server &b%s&a.", true),
|
||||
|
||||
TRACK_INFO(
|
||||
PREFIX + "&d-> &eTrack: &6%s" + "\n" +
|
||||
|
||||
@@ -29,6 +29,10 @@ public enum Permission {
|
||||
USER_UNSETPERMISSION("unsetpermission", PermissionGroup.USER),
|
||||
USER_ADDGROUP("addgroup", PermissionGroup.USER),
|
||||
USER_REMOVEGROUP("removegroup", PermissionGroup.USER),
|
||||
USER_SET_TEMP_PERMISSION("settemppermission", PermissionGroup.USER),
|
||||
USER_UNSET_TEMP_PERMISSION("unsettemppermission", PermissionGroup.USER),
|
||||
USER_ADDTEMPGROUP("addtempgroup", PermissionGroup.USER),
|
||||
USER_REMOVETEMPGROUP("removetempgroup", PermissionGroup.USER),
|
||||
USER_SETPRIMARYGROUP("setprimarygroup", PermissionGroup.USER),
|
||||
USER_SHOWTRACKS("showtracks", PermissionGroup.USER),
|
||||
USER_PROMOTE("promote", PermissionGroup.USER),
|
||||
@@ -44,6 +48,10 @@ public enum Permission {
|
||||
GROUP_UNSETPERMISSION("unsetpermission", PermissionGroup.GROUP),
|
||||
GROUP_SETINHERIT("setinherit", PermissionGroup.GROUP),
|
||||
GROUP_UNSETINHERIT("unsetinherit", PermissionGroup.GROUP),
|
||||
GROUP_SET_TEMP_PERMISSION("settemppermission", PermissionGroup.GROUP),
|
||||
GROUP_UNSET_TEMP_PERMISSION("unsettemppermission", PermissionGroup.GROUP),
|
||||
GROUP_SET_TEMP_INHERIT("settempinherit", PermissionGroup.GROUP),
|
||||
GROUP_UNSET_TEMP_INHERIT("unsettempinherit", PermissionGroup.GROUP),
|
||||
GROUP_SHOWTRACKS("showtracks", PermissionGroup.GROUP),
|
||||
GROUP_CLEAR("clear", PermissionGroup.GROUP),
|
||||
|
||||
|
||||
@@ -1,14 +1,18 @@
|
||||
package me.lucko.luckperms.data;
|
||||
|
||||
import lombok.AccessLevel;
|
||||
import lombok.Getter;
|
||||
import lombok.RequiredArgsConstructor;
|
||||
import lombok.Setter;
|
||||
import me.lucko.luckperms.LuckPermsPlugin;
|
||||
import me.lucko.luckperms.api.data.Callback;
|
||||
import me.lucko.luckperms.groups.Group;
|
||||
import me.lucko.luckperms.tracks.Track;
|
||||
import me.lucko.luckperms.users.User;
|
||||
|
||||
import java.util.UUID;
|
||||
|
||||
@RequiredArgsConstructor(access = AccessLevel.PROTECTED)
|
||||
public abstract class Datastore {
|
||||
protected final LuckPermsPlugin plugin;
|
||||
|
||||
@@ -17,13 +21,7 @@ public abstract class Datastore {
|
||||
|
||||
@Getter
|
||||
@Setter
|
||||
private boolean acceptingLogins;
|
||||
|
||||
protected Datastore(LuckPermsPlugin plugin, String name) {
|
||||
this.plugin = plugin;
|
||||
this.name = name;
|
||||
this.acceptingLogins = false;
|
||||
}
|
||||
private boolean acceptingLogins = false;
|
||||
|
||||
/**
|
||||
* Execute a runnable asynchronously
|
||||
@@ -45,6 +43,10 @@ public abstract class Datastore {
|
||||
doSync(() -> callback.onComplete(result));
|
||||
}
|
||||
|
||||
private void runCallback(UUID result, Callback.GetUUID callback) {
|
||||
doSync(() -> callback.onComplete(result));
|
||||
}
|
||||
|
||||
/*
|
||||
These methods are called immediately and in the same thread as they are called in.
|
||||
*/
|
||||
@@ -128,15 +130,7 @@ public abstract class Datastore {
|
||||
doAsync(() -> runCallback(saveUUIDData(username, uuid), callback));
|
||||
}
|
||||
|
||||
public void getUUID(String username, GetUUIDCallback callback) {
|
||||
doAsync(() -> doSync(() -> callback.onComplete(getUUID(username))));
|
||||
}
|
||||
|
||||
public interface Callback {
|
||||
void onComplete(boolean success);
|
||||
}
|
||||
|
||||
public interface GetUUIDCallback {
|
||||
void onComplete(UUID uuid);
|
||||
public void getUUID(String username, Callback.GetUUID callback) {
|
||||
doAsync(() -> runCallback(getUUID(username), callback));
|
||||
}
|
||||
}
|
||||
@@ -2,6 +2,7 @@ package me.lucko.luckperms.data.methods;
|
||||
|
||||
import com.google.gson.stream.JsonReader;
|
||||
import com.google.gson.stream.JsonWriter;
|
||||
import lombok.Cleanup;
|
||||
import me.lucko.luckperms.LuckPermsPlugin;
|
||||
import me.lucko.luckperms.data.Datastore;
|
||||
import me.lucko.luckperms.groups.Group;
|
||||
@@ -31,61 +32,32 @@ public class FlatfileDatastore extends Datastore {
|
||||
|
||||
private boolean doWrite(File file, WriteOperation writeOperation) {
|
||||
boolean success = false;
|
||||
|
||||
FileWriter fileWriter = null;
|
||||
BufferedWriter bufferedWriter = null;
|
||||
JsonWriter jsonWriter = null;
|
||||
|
||||
try {
|
||||
fileWriter = new FileWriter(file);
|
||||
bufferedWriter = new BufferedWriter(fileWriter);
|
||||
jsonWriter = new JsonWriter(bufferedWriter);
|
||||
@Cleanup FileWriter fileWriter = new FileWriter(file);
|
||||
@Cleanup BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
|
||||
@Cleanup JsonWriter jsonWriter = new JsonWriter(bufferedWriter);
|
||||
jsonWriter.setIndent(" ");
|
||||
success = writeOperation.onRun(jsonWriter);
|
||||
jsonWriter.flush();
|
||||
} catch (IOException e) {
|
||||
e.printStackTrace();
|
||||
} finally {
|
||||
close(jsonWriter);
|
||||
close(bufferedWriter);
|
||||
close(fileWriter);
|
||||
}
|
||||
|
||||
return success;
|
||||
}
|
||||
|
||||
private boolean doRead(File file, ReadOperation readOperation) {
|
||||
boolean success = false;
|
||||
|
||||
FileReader fileReader = null;
|
||||
BufferedReader bufferedReader = null;
|
||||
JsonReader jsonReader = null;
|
||||
|
||||
try {
|
||||
fileReader = new FileReader(file);
|
||||
bufferedReader = new BufferedReader(fileReader);
|
||||
jsonReader = new JsonReader(bufferedReader);
|
||||
@Cleanup FileReader fileReader = new FileReader(file);
|
||||
@Cleanup BufferedReader bufferedReader = new BufferedReader(fileReader);
|
||||
@Cleanup JsonReader jsonReader = new JsonReader(bufferedReader);
|
||||
success = readOperation.onRun(jsonReader);
|
||||
} catch (IOException e) {
|
||||
e.printStackTrace();
|
||||
} finally {
|
||||
close(jsonReader);
|
||||
close(bufferedReader);
|
||||
close(fileReader);
|
||||
}
|
||||
|
||||
return success;
|
||||
}
|
||||
|
||||
private static void close(AutoCloseable closeable) {
|
||||
if (closeable == null) return;
|
||||
try {
|
||||
closeable.close();
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void init() {
|
||||
try {
|
||||
@@ -499,12 +471,9 @@ public class FlatfileDatastore extends Datastore {
|
||||
private Map<String, String> getUUIDCache() {
|
||||
Map<String, String> cache = new HashMap<>();
|
||||
|
||||
FileReader fileReader = null;
|
||||
BufferedReader bufferedReader = null;
|
||||
|
||||
try {
|
||||
fileReader = new FileReader(uuidData);
|
||||
bufferedReader = new BufferedReader(fileReader);
|
||||
@Cleanup FileReader fileReader = new FileReader(uuidData);
|
||||
@Cleanup BufferedReader bufferedReader = new BufferedReader(fileReader);
|
||||
|
||||
Properties props = new Properties();
|
||||
props.load(bufferedReader);
|
||||
@@ -514,21 +483,14 @@ public class FlatfileDatastore extends Datastore {
|
||||
|
||||
} catch (IOException e) {
|
||||
e.printStackTrace();
|
||||
} finally {
|
||||
close(bufferedReader);
|
||||
close(fileReader);
|
||||
}
|
||||
|
||||
return cache;
|
||||
}
|
||||
|
||||
private void saveUUIDCache(Map<String, String> cache) {
|
||||
FileWriter fileWriter = null;
|
||||
BufferedWriter bufferedWriter = null;
|
||||
|
||||
try {
|
||||
fileWriter = new FileWriter(uuidData);
|
||||
bufferedWriter = new BufferedWriter(fileWriter);
|
||||
@Cleanup FileWriter fileWriter = new FileWriter(uuidData);
|
||||
@Cleanup BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
|
||||
|
||||
Properties properties = new Properties();
|
||||
properties.putAll(cache);
|
||||
@@ -536,9 +498,6 @@ public class FlatfileDatastore extends Datastore {
|
||||
|
||||
} catch (IOException e) {
|
||||
e.printStackTrace();
|
||||
} finally {
|
||||
close(bufferedWriter);
|
||||
close(fileWriter);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -3,6 +3,7 @@ package me.lucko.luckperms.data.methods;
|
||||
import com.google.gson.Gson;
|
||||
import com.google.gson.reflect.TypeToken;
|
||||
import lombok.AllArgsConstructor;
|
||||
import lombok.Cleanup;
|
||||
import lombok.Getter;
|
||||
import me.lucko.luckperms.LuckPermsPlugin;
|
||||
import me.lucko.luckperms.data.Datastore;
|
||||
@@ -57,66 +58,40 @@ abstract class SQLDatastore extends Datastore {
|
||||
|
||||
abstract Connection getConnection() throws SQLException;
|
||||
|
||||
private static void close(AutoCloseable closeable) {
|
||||
if (closeable == null) return;
|
||||
try {
|
||||
closeable.close();
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
private boolean runQuery(QueryPS queryPS) {
|
||||
boolean success = false;
|
||||
|
||||
Connection connection = null;
|
||||
PreparedStatement preparedStatement = null;
|
||||
try {
|
||||
connection = getConnection();
|
||||
@Cleanup Connection connection = getConnection();
|
||||
if (connection == null) {
|
||||
throw new IllegalStateException("SQL connection is null");
|
||||
}
|
||||
|
||||
preparedStatement = connection.prepareStatement(queryPS.getQuery());
|
||||
@Cleanup PreparedStatement preparedStatement = connection.prepareStatement(queryPS.getQuery());
|
||||
queryPS.onRun(preparedStatement);
|
||||
preparedStatement.execute();
|
||||
success = true;
|
||||
|
||||
} catch (SQLException e) {
|
||||
e.printStackTrace();
|
||||
} finally {
|
||||
close(preparedStatement);
|
||||
close(connection);
|
||||
}
|
||||
return success;
|
||||
}
|
||||
|
||||
private boolean runQuery(QueryRS queryRS) {
|
||||
boolean success = false;
|
||||
|
||||
Connection connection = null;
|
||||
PreparedStatement preparedStatement = null;
|
||||
ResultSet resultSet = null;
|
||||
|
||||
try {
|
||||
connection = getConnection();
|
||||
@Cleanup Connection connection = getConnection();
|
||||
if (connection == null) {
|
||||
throw new IllegalStateException("SQL connection is null");
|
||||
}
|
||||
|
||||
preparedStatement = connection.prepareStatement(queryRS.getQuery());
|
||||
@Cleanup PreparedStatement preparedStatement = connection.prepareStatement(queryRS.getQuery());
|
||||
queryRS.onRun(preparedStatement);
|
||||
preparedStatement.execute();
|
||||
|
||||
resultSet = preparedStatement.executeQuery();
|
||||
@Cleanup ResultSet resultSet = preparedStatement.executeQuery();
|
||||
success = queryRS.onResult(resultSet);
|
||||
|
||||
} catch (SQLException e) {
|
||||
e.printStackTrace();
|
||||
} finally {
|
||||
close(resultSet);
|
||||
close(preparedStatement);
|
||||
close(connection);
|
||||
}
|
||||
return success;
|
||||
}
|
||||
@@ -414,6 +389,8 @@ abstract class SQLDatastore extends Datastore {
|
||||
preparedStatement.setString(1, track.getName());
|
||||
}
|
||||
});
|
||||
|
||||
if (success) plugin.getTrackManager().unloadTrack(track);
|
||||
return success;
|
||||
}
|
||||
|
||||
|
||||
@@ -1,9 +1,13 @@
|
||||
package me.lucko.luckperms.groups;
|
||||
|
||||
import lombok.EqualsAndHashCode;
|
||||
import lombok.Getter;
|
||||
import lombok.ToString;
|
||||
import me.lucko.luckperms.LuckPermsPlugin;
|
||||
import me.lucko.luckperms.utils.PermissionObject;
|
||||
|
||||
@ToString(of = {"name"})
|
||||
@EqualsAndHashCode(of = {"name"}, callSuper = false)
|
||||
public class Group extends PermissionObject {
|
||||
|
||||
/**
|
||||
@@ -13,7 +17,7 @@ public class Group extends PermissionObject {
|
||||
private final String name;
|
||||
|
||||
Group(String name, LuckPermsPlugin plugin) {
|
||||
super(plugin, name);
|
||||
super(name, plugin);
|
||||
this.name = name;
|
||||
}
|
||||
|
||||
@@ -23,9 +27,4 @@ public class Group extends PermissionObject {
|
||||
public void clearNodes() {
|
||||
getNodes().clear();
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return getName();
|
||||
}
|
||||
}
|
||||
@@ -1,11 +1,13 @@
|
||||
package me.lucko.luckperms.groups;
|
||||
|
||||
import lombok.Getter;
|
||||
import lombok.RequiredArgsConstructor;
|
||||
import me.lucko.luckperms.LuckPermsPlugin;
|
||||
|
||||
import java.util.Map;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
|
||||
@RequiredArgsConstructor
|
||||
public class GroupManager {
|
||||
private final LuckPermsPlugin plugin;
|
||||
|
||||
@@ -15,10 +17,6 @@ public class GroupManager {
|
||||
@Getter
|
||||
private final Map<String, Group> groups = new ConcurrentHashMap<>();
|
||||
|
||||
public GroupManager(LuckPermsPlugin plugin) {
|
||||
this.plugin = plugin;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a group object by name
|
||||
* @param name The name to search by
|
||||
@@ -75,19 +73,6 @@ public class GroupManager {
|
||||
groups.clear();
|
||||
}
|
||||
|
||||
/**
|
||||
* Load all groups from the datastore
|
||||
*/
|
||||
public void loadAllGroups() {
|
||||
plugin.getDatastore().loadAllGroups(success -> {
|
||||
String defaultGroup = plugin.getConfiguration().getDefaultGroupName();
|
||||
|
||||
if (!groups.keySet().contains(defaultGroup)) {
|
||||
plugin.getDatastore().createAndLoadGroup(defaultGroup, success1 -> {});
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Makes a new group object
|
||||
* @param name The name of the group
|
||||
|
||||
@@ -1,6 +1,9 @@
|
||||
package me.lucko.luckperms.tracks;
|
||||
|
||||
import lombok.EqualsAndHashCode;
|
||||
import lombok.Getter;
|
||||
import lombok.RequiredArgsConstructor;
|
||||
import lombok.ToString;
|
||||
import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
|
||||
import me.lucko.luckperms.exceptions.ObjectLacksException;
|
||||
import me.lucko.luckperms.groups.Group;
|
||||
@@ -9,6 +12,9 @@ import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
|
||||
@ToString(of = {"name"})
|
||||
@EqualsAndHashCode(of = {"name"}, callSuper = false)
|
||||
@RequiredArgsConstructor
|
||||
public class Track {
|
||||
|
||||
/**
|
||||
@@ -20,11 +26,7 @@ public class Track {
|
||||
/**
|
||||
* The groups within this track
|
||||
*/
|
||||
private List<String> groups = new ArrayList<>();
|
||||
|
||||
Track(String name) {
|
||||
this.name = name;
|
||||
}
|
||||
private List<String> groups = Collections.synchronizedList(new ArrayList<>());
|
||||
|
||||
/**
|
||||
* Gets an ordered list of the groups on this track
|
||||
@@ -165,12 +167,6 @@ public class Track {
|
||||
groups.clear();
|
||||
}
|
||||
|
||||
private void assertContains(Group g) throws ObjectLacksException {
|
||||
if (!containsGroup(g)) {
|
||||
throw new ObjectLacksException();
|
||||
}
|
||||
}
|
||||
|
||||
private void assertNotContains(Group g) throws ObjectAlreadyHasException {
|
||||
if (containsGroup(g)) {
|
||||
throw new ObjectAlreadyHasException();
|
||||
@@ -182,16 +178,4 @@ public class Track {
|
||||
throw new ObjectLacksException();
|
||||
}
|
||||
}
|
||||
|
||||
private void assertNotContains(String g) throws ObjectAlreadyHasException {
|
||||
if (containsGroup(g)) {
|
||||
throw new ObjectAlreadyHasException();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return name;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,7 +1,6 @@
|
||||
package me.lucko.luckperms.tracks;
|
||||
|
||||
import lombok.Getter;
|
||||
import me.lucko.luckperms.LuckPermsPlugin;
|
||||
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
@@ -9,7 +8,6 @@ import java.util.concurrent.ConcurrentHashMap;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
public class TrackManager {
|
||||
private final LuckPermsPlugin plugin;
|
||||
|
||||
/**
|
||||
* A {@link Map} containing all loaded tracks
|
||||
@@ -17,10 +15,6 @@ public class TrackManager {
|
||||
@Getter
|
||||
private final Map<String, Track> tracks = new ConcurrentHashMap<>();
|
||||
|
||||
public TrackManager(LuckPermsPlugin plugin) {
|
||||
this.plugin = plugin;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a track object by name
|
||||
* @param name the name to search by
|
||||
@@ -86,13 +80,6 @@ public class TrackManager {
|
||||
tracks.clear();
|
||||
}
|
||||
|
||||
/**
|
||||
* Load all tracks from the datastore
|
||||
*/
|
||||
public void loadAllTracks() {
|
||||
plugin.getDatastore().loadAllTracks(success -> {});
|
||||
}
|
||||
|
||||
/**
|
||||
* Makes a new track object
|
||||
* @param name The name of the track
|
||||
|
||||
@@ -1,7 +1,9 @@
|
||||
package me.lucko.luckperms.users;
|
||||
|
||||
import lombok.EqualsAndHashCode;
|
||||
import lombok.Getter;
|
||||
import lombok.Setter;
|
||||
import lombok.ToString;
|
||||
import me.lucko.luckperms.LuckPermsPlugin;
|
||||
import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
|
||||
import me.lucko.luckperms.exceptions.ObjectLacksException;
|
||||
@@ -12,6 +14,8 @@ import me.lucko.luckperms.utils.PermissionObject;
|
||||
import java.util.*;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
@ToString(of = {"uuid"})
|
||||
@EqualsAndHashCode(of = {"uuid"}, callSuper = false)
|
||||
public abstract class User extends PermissionObject {
|
||||
|
||||
/**
|
||||
@@ -35,13 +39,13 @@ public abstract class User extends PermissionObject {
|
||||
private String primaryGroup = null;
|
||||
|
||||
User(UUID uuid, LuckPermsPlugin plugin) {
|
||||
super(plugin, uuid.toString());
|
||||
super(uuid.toString(), plugin);
|
||||
this.uuid = uuid;
|
||||
this.name = null;
|
||||
}
|
||||
|
||||
User(UUID uuid, String name, LuckPermsPlugin plugin) {
|
||||
super(plugin, uuid.toString());
|
||||
super(uuid.toString(), plugin);
|
||||
this.uuid = uuid;
|
||||
this.name = name;
|
||||
}
|
||||
@@ -93,6 +97,31 @@ public abstract class User extends PermissionObject {
|
||||
setPermission("group." + group.getName(), true, server);
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a user to a group on a specific server
|
||||
* @param group The group to add the user to
|
||||
* @param expireAt when the group should expire
|
||||
* @throws ObjectAlreadyHasException if the user is already a member of the group on that server
|
||||
*/
|
||||
public void addGroup(Group group, long expireAt) throws ObjectAlreadyHasException {
|
||||
setPermission("group." + group.getName(), true, expireAt);
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a user to a group on a specific server
|
||||
* @param group The group to add the user to
|
||||
* @param server The server to add the group on
|
||||
* @param expireAt when the group should expire
|
||||
* @throws ObjectAlreadyHasException if the user is already a member of the group on that server
|
||||
*/
|
||||
public void addGroup(Group group, String server, long expireAt) throws ObjectAlreadyHasException {
|
||||
if (server == null) {
|
||||
server = "global";
|
||||
}
|
||||
|
||||
setPermission("group." + group.getName(), true, server, expireAt);
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove the user from a group
|
||||
* @param group the group to remove the user from
|
||||
@@ -102,6 +131,16 @@ public abstract class User extends PermissionObject {
|
||||
removeGroup(group, "global");
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove the user from a group
|
||||
* @param group the group to remove the user from
|
||||
* @param temporary if the group being removed is temporary
|
||||
* @throws ObjectLacksException if the user isn't a member of the group
|
||||
*/
|
||||
public void removeGroup(Group group, boolean temporary) throws ObjectLacksException {
|
||||
removeGroup(group, "global", temporary);
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove the user from a group
|
||||
* @param group The group to remove the user from
|
||||
@@ -116,6 +155,21 @@ public abstract class User extends PermissionObject {
|
||||
unsetPermission("group." + group.getName(), server);
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove the user from a group
|
||||
* @param group The group to remove the user from
|
||||
* @param server The server to remove the group on
|
||||
* @param temporary if the group being removed is temporary
|
||||
* @throws ObjectLacksException if the user isn't a member of the group
|
||||
*/
|
||||
public void removeGroup(Group group, String server, boolean temporary) throws ObjectLacksException {
|
||||
if (server == null) {
|
||||
server = "global";
|
||||
}
|
||||
|
||||
unsetPermission("group." + group.getName(), server, temporary);
|
||||
}
|
||||
|
||||
/**
|
||||
* Clear all of the users permission nodes
|
||||
*/
|
||||
@@ -143,7 +197,8 @@ public abstract class User extends PermissionObject {
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a {@link List} of the groups the user is a member of on a specific server with the option to include global groups or all groups
|
||||
* Get a {@link List} of the groups the user is a member of on a specific server with the option to include global
|
||||
* groups or all groups
|
||||
* @param server Which server to check on
|
||||
* @param excludedGroups groups to exclude (prevents circular inheritance issues)
|
||||
* @param includeGlobal Whether to include global groups
|
||||
@@ -172,10 +227,10 @@ public abstract class User extends PermissionObject {
|
||||
final Map<String, Boolean> groupNodes = new HashMap<>();
|
||||
|
||||
// Sorts the permissions and puts them into a priority order
|
||||
for (Map.Entry<String, Boolean> node : getNodes().entrySet()) {
|
||||
for (Map.Entry<String, Boolean> node : convertTemporaryPerms().entrySet()) {
|
||||
serverSpecific:
|
||||
if (node.getKey().contains("/")) {
|
||||
String[] parts = node.getKey().split("\\/", 2);
|
||||
String[] parts = Patterns.SERVER_SPLIT.split(node.getKey(), 2);
|
||||
|
||||
if (parts[0].equalsIgnoreCase("global")) {
|
||||
// REGULAR
|
||||
@@ -224,9 +279,4 @@ public abstract class User extends PermissionObject {
|
||||
);
|
||||
return groups;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return getUuid().toString();
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,7 @@
|
||||
package me.lucko.luckperms.users;
|
||||
|
||||
import lombok.Getter;
|
||||
import lombok.RequiredArgsConstructor;
|
||||
import me.lucko.luckperms.LuckPermsPlugin;
|
||||
import me.lucko.luckperms.data.Datastore;
|
||||
import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
|
||||
@@ -10,6 +11,7 @@ import java.util.NoSuchElementException;
|
||||
import java.util.UUID;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
|
||||
@RequiredArgsConstructor
|
||||
public abstract class UserManager {
|
||||
|
||||
/**
|
||||
@@ -23,10 +25,6 @@ public abstract class UserManager {
|
||||
*/
|
||||
private final LuckPermsPlugin plugin;
|
||||
|
||||
public UserManager(LuckPermsPlugin plugin) {
|
||||
this.plugin = plugin;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a user object by UUID
|
||||
* @param uuid The uuid to search by
|
||||
|
||||
@@ -0,0 +1,171 @@
|
||||
package me.lucko.luckperms.utils;
|
||||
|
||||
import lombok.experimental.UtilityClass;
|
||||
|
||||
import java.util.Calendar;
|
||||
import java.util.GregorianCalendar;
|
||||
import java.util.regex.Matcher;
|
||||
import java.util.regex.Pattern;
|
||||
|
||||
/**
|
||||
* All credit to Essentials / EssentialsX for this class
|
||||
* https://github.com/drtshock/Essentials/blob/2.x/Essentials/src/com/earth2me/essentials/utils/DateUtil.java
|
||||
* https://github.com/essentials/Essentials/blob/2.x/Essentials/src/com/earth2me/essentials/utils/DateUtil.java
|
||||
*/
|
||||
@UtilityClass
|
||||
public class DateUtil {
|
||||
private static final Pattern TIME_PATTERN = Pattern.compile("(?:([0-9]+)\\s*y[a-z]*[,\\s]*)?" + "(?:([0-9]+)\\s*mo[a-z]*[,\\s]*)?" + "(?:([0-9]+)\\s*w[a-z]*[,\\s]*)?" + "(?:([0-9]+)\\s*d[a-z]*[,\\s]*)?" + "(?:([0-9]+)\\s*h[a-z]*[,\\s]*)?" + "(?:([0-9]+)\\s*m[a-z]*[,\\s]*)?" + "(?:([0-9]+)\\s*(?:s[a-z]*)?)?", Pattern.CASE_INSENSITIVE);
|
||||
private static final int MAX_YEARS = 100000;
|
||||
|
||||
public static boolean shouldExpire(long unixTime) {
|
||||
return unixTime < (System.currentTimeMillis() / 1000);
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts a time string to a unix timestamp
|
||||
* @param time the time string
|
||||
* @return a unix timestamp
|
||||
* @throws IllegalDateException if the date input was invalid
|
||||
*/
|
||||
public static long parseDateDiff(String time, boolean future) throws IllegalDateException {
|
||||
Matcher m = TIME_PATTERN.matcher(time);
|
||||
int years = 0;
|
||||
int months = 0;
|
||||
int weeks = 0;
|
||||
int days = 0;
|
||||
int hours = 0;
|
||||
int minutes = 0;
|
||||
int seconds = 0;
|
||||
boolean found = false;
|
||||
while (m.find()) {
|
||||
if (m.group() == null || m.group().isEmpty()) {
|
||||
continue;
|
||||
}
|
||||
for (int i = 0; i < m.groupCount(); i++) {
|
||||
if (m.group(i) != null && !m.group(i).isEmpty()) {
|
||||
found = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (found) {
|
||||
if (m.group(1) != null && !m.group(1).isEmpty()) {
|
||||
years = Integer.parseInt(m.group(1));
|
||||
}
|
||||
if (m.group(2) != null && !m.group(2).isEmpty()) {
|
||||
months = Integer.parseInt(m.group(2));
|
||||
}
|
||||
if (m.group(3) != null && !m.group(3).isEmpty()) {
|
||||
weeks = Integer.parseInt(m.group(3));
|
||||
}
|
||||
if (m.group(4) != null && !m.group(4).isEmpty()) {
|
||||
days = Integer.parseInt(m.group(4));
|
||||
}
|
||||
if (m.group(5) != null && !m.group(5).isEmpty()) {
|
||||
hours = Integer.parseInt(m.group(5));
|
||||
}
|
||||
if (m.group(6) != null && !m.group(6).isEmpty()) {
|
||||
minutes = Integer.parseInt(m.group(6));
|
||||
}
|
||||
if (m.group(7) != null && !m.group(7).isEmpty()) {
|
||||
seconds = Integer.parseInt(m.group(7));
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!found) {
|
||||
throw new IllegalDateException();
|
||||
}
|
||||
Calendar c = new GregorianCalendar();
|
||||
if (years > 0) {
|
||||
if (years > MAX_YEARS) {
|
||||
years = MAX_YEARS;
|
||||
}
|
||||
c.add(Calendar.YEAR, years * (future ? 1 : -1));
|
||||
}
|
||||
if (months > 0) {
|
||||
c.add(Calendar.MONTH, months * (future ? 1 : -1));
|
||||
}
|
||||
if (weeks > 0) {
|
||||
c.add(Calendar.WEEK_OF_YEAR, weeks * (future ? 1 : -1));
|
||||
}
|
||||
if (days > 0) {
|
||||
c.add(Calendar.DAY_OF_MONTH, days * (future ? 1 : -1));
|
||||
}
|
||||
if (hours > 0) {
|
||||
c.add(Calendar.HOUR_OF_DAY, hours * (future ? 1 : -1));
|
||||
}
|
||||
if (minutes > 0) {
|
||||
c.add(Calendar.MINUTE, minutes * (future ? 1 : -1));
|
||||
}
|
||||
if (seconds > 0) {
|
||||
c.add(Calendar.SECOND, seconds * (future ? 1 : -1));
|
||||
}
|
||||
Calendar max = new GregorianCalendar();
|
||||
max.add(Calendar.YEAR, 10);
|
||||
if (c.after(max)) {
|
||||
return (max.getTimeInMillis() / 1000) + 1;
|
||||
}
|
||||
return (c.getTimeInMillis() / 1000) + 1;
|
||||
}
|
||||
|
||||
private static int dateDiff(int type, Calendar fromDate, Calendar toDate, boolean future) {
|
||||
int year = Calendar.YEAR;
|
||||
|
||||
int fromYear = fromDate.get(year);
|
||||
int toYear = toDate.get(year);
|
||||
if (Math.abs(fromYear - toYear) > MAX_YEARS) {
|
||||
toDate.set(year, fromYear +
|
||||
(future ? MAX_YEARS : -MAX_YEARS));
|
||||
}
|
||||
|
||||
int diff = 0;
|
||||
long savedDate = fromDate.getTimeInMillis();
|
||||
while ((future && !fromDate.after(toDate)) || (!future && !fromDate.before(toDate))) {
|
||||
savedDate = fromDate.getTimeInMillis();
|
||||
fromDate.add(type, future ? 1 : -1);
|
||||
diff++;
|
||||
}
|
||||
diff--;
|
||||
fromDate.setTimeInMillis(savedDate);
|
||||
return diff;
|
||||
}
|
||||
|
||||
public static String formatDateDiff(long unixTime) {
|
||||
Calendar c = new GregorianCalendar();
|
||||
c.setTimeInMillis(unixTime * 1000);
|
||||
Calendar now = new GregorianCalendar();
|
||||
return DateUtil.formatDateDiff(now, c);
|
||||
}
|
||||
|
||||
private static String formatDateDiff(Calendar fromDate, Calendar toDate) {
|
||||
boolean future = false;
|
||||
if (toDate.equals(fromDate)) {
|
||||
return "now";
|
||||
}
|
||||
if (toDate.after(fromDate)) {
|
||||
future = true;
|
||||
}
|
||||
StringBuilder sb = new StringBuilder();
|
||||
int[] types = new int[]{Calendar.YEAR, Calendar.MONTH, Calendar.DAY_OF_MONTH, Calendar.HOUR_OF_DAY, Calendar.MINUTE, Calendar.SECOND};
|
||||
String[] names = new String[]{"year", "years", "month", "months", "day", "days", "hour", "hours", "minute", "minutes", "second", "seconds"};
|
||||
int accuracy = 0;
|
||||
for (int i = 0; i < types.length; i++) {
|
||||
if (accuracy > 2) {
|
||||
break;
|
||||
}
|
||||
int diff = dateDiff(types[i], fromDate, toDate, future);
|
||||
if (diff > 0) {
|
||||
accuracy++;
|
||||
sb.append(" ").append(diff).append(" ").append(names[i * 2 + (diff > 1 ? 1 : 0)]);
|
||||
}
|
||||
}
|
||||
if (sb.length() == 0) {
|
||||
return "now";
|
||||
}
|
||||
return sb.toString().trim();
|
||||
}
|
||||
|
||||
public static class IllegalDateException extends Exception {
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,13 +1,71 @@
|
||||
package me.lucko.luckperms.utils;
|
||||
|
||||
public interface LPConfiguration {
|
||||
import lombok.AccessLevel;
|
||||
import lombok.Getter;
|
||||
import me.lucko.luckperms.LuckPermsPlugin;
|
||||
|
||||
String getServer();
|
||||
int getSyncTime();
|
||||
String getDefaultGroupNode();
|
||||
String getDefaultGroupName();
|
||||
boolean getIncludeGlobalPerms();
|
||||
String getDatabaseValue(String value);
|
||||
String getStorageMethod();
|
||||
public abstract class LPConfiguration<T extends LuckPermsPlugin> {
|
||||
|
||||
@Getter(AccessLevel.PROTECTED)
|
||||
private final T plugin;
|
||||
|
||||
private final String defaultServerName;
|
||||
private final boolean defaultIncludeGlobal;
|
||||
private final String defaultStorage;
|
||||
|
||||
public LPConfiguration(T plugin, String defaultServerName, boolean defaultIncludeGlobal, String defaultStorage) {
|
||||
this.plugin = plugin;
|
||||
this.defaultServerName = defaultServerName;
|
||||
this.defaultIncludeGlobal = defaultIncludeGlobal;
|
||||
this.defaultStorage = defaultStorage;
|
||||
init();
|
||||
|
||||
if (Patterns.NON_ALPHA_NUMERIC.matcher(getServer()).find()) {
|
||||
plugin.getLogger().severe("Server name defined in config.yml contains invalid characters. Server names can " +
|
||||
"only contain alphanumeric characters.\nDefined server name '" + getServer() + "' will be replaced with '" +
|
||||
defaultServerName + "' (the default)");
|
||||
set("server", defaultServerName);
|
||||
}
|
||||
|
||||
if (Patterns.NON_ALPHA_NUMERIC.matcher(getDefaultGroupName()).find()) {
|
||||
plugin.getLogger().severe("Default group defined in config.yml contains invalid characters. Group names can " +
|
||||
"only contain alphanumeric characters.\nDefined default group name '" + getDefaultGroupName() +
|
||||
"' will be replaced with 'default' (the default)");
|
||||
set("default-group", "default");
|
||||
}
|
||||
}
|
||||
|
||||
protected abstract void init();
|
||||
protected abstract void set(String path, Object value);
|
||||
protected abstract String getString(String path, String def);
|
||||
protected abstract int getInt(String path, int def);
|
||||
protected abstract boolean getBoolean(String path, boolean def);
|
||||
|
||||
public String getServer() {
|
||||
return getString("server", defaultServerName);
|
||||
}
|
||||
|
||||
public int getSyncTime() {
|
||||
return getInt("sql.sync-minutes", 3);
|
||||
}
|
||||
|
||||
public String getDefaultGroupNode() {
|
||||
return "group." + getDefaultGroupName();
|
||||
}
|
||||
|
||||
public String getDefaultGroupName() {
|
||||
return getString("default-group", "default");
|
||||
}
|
||||
|
||||
public boolean getIncludeGlobalPerms() {
|
||||
return getBoolean("include-global", defaultIncludeGlobal);
|
||||
}
|
||||
|
||||
public String getDatabaseValue(String value) {
|
||||
return getString("sql." + value, null);
|
||||
}
|
||||
|
||||
public String getStorageMethod() {
|
||||
return getString("storage-method", defaultStorage);
|
||||
}
|
||||
}
|
||||
@@ -1,14 +1,16 @@
|
||||
package me.lucko.luckperms.utils;
|
||||
|
||||
import lombok.experimental.UtilityClass;
|
||||
|
||||
import java.util.regex.Pattern;
|
||||
|
||||
@UtilityClass
|
||||
public class Patterns {
|
||||
|
||||
public static final Pattern SERVER_SPLIT = Pattern.compile("\\/");
|
||||
public static final Pattern TEMP_SPLIT = Pattern.compile("\\$");
|
||||
public static final Pattern DOT_SPLIT = Pattern.compile("\\.");
|
||||
public static final Pattern GROUP_MATCH = Pattern.compile("group\\..*");
|
||||
public static final Pattern NON_ALPHA_NUMERIC = Pattern.compile("[^A-Za-z0-9]");
|
||||
|
||||
private Patterns() {}
|
||||
public static final Pattern NON_USERNAME = Pattern.compile("[^A-Za-z0-9_]");
|
||||
|
||||
}
|
||||
Loaded 100 of 102 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user