diff --git a/api/src/main/java/me/lucko/luckperms/api/context/ContextCalculator.java b/api/src/main/java/me/lucko/luckperms/api/context/ContextCalculator.java index aec773715..5ebf34950 100644 --- a/api/src/main/java/me/lucko/luckperms/api/context/ContextCalculator.java +++ b/api/src/main/java/me/lucko/luckperms/api/context/ContextCalculator.java @@ -22,8 +22,6 @@ package me.lucko.luckperms.api.context; -import java.util.Map; - /** * Calculates whether contexts are applicable to {@link T} * @@ -43,13 +41,4 @@ public interface ContextCalculator { */ MutableContextSet giveApplicableContext(T subject, MutableContextSet accumulator); - /** - * Checks to see if a context is applicable to a subject - * - * @param subject the subject to check against - * @param context the context to check for - * @return true if met, or false if not. If this calculator does not calculate the given context, return false. - */ - boolean isContextApplicable(T subject, Map.Entry context); - } diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/LPBukkitPlugin.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/LPBukkitPlugin.java index eba042cc0..bff6775ca 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/LPBukkitPlugin.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/LPBukkitPlugin.java @@ -47,7 +47,7 @@ import me.lucko.luckperms.common.config.ConfigKeys; import me.lucko.luckperms.common.config.LuckPermsConfiguration; import me.lucko.luckperms.common.constants.Permission; import me.lucko.luckperms.common.contexts.ContextManager; -import me.lucko.luckperms.common.contexts.ServerCalculator; +import me.lucko.luckperms.common.contexts.StaticCalculator; import me.lucko.luckperms.common.core.UuidCache; import me.lucko.luckperms.common.core.model.User; import me.lucko.luckperms.common.dependencies.Dependency; @@ -273,7 +273,7 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin { contextManager = new ContextManager<>(); worldCalculator = new WorldCalculator(this); contextManager.registerCalculator(worldCalculator); - contextManager.registerCalculator(new ServerCalculator<>(getConfiguration())); + contextManager.registerCalculator(new StaticCalculator<>(getConfiguration())); // Provide vault support tryVaultHook(false); @@ -560,6 +560,7 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin { MutableContextSet set = MutableContextSet.create(); set.add("server", getConfiguration().get(ConfigKeys.SERVER)); set.add("world", s); + set.addAll(configuration.getStaticContexts().getContextSet()); return set.makeImmutable(); }) .collect(Collectors.toList()) @@ -574,6 +575,7 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin { MutableContextSet set = MutableContextSet.create(); set.add("server", getConfiguration().get(ConfigKeys.VAULT_SERVER)); set.add("world", s); + set.addAll(configuration.getStaticContexts().getContextSet()); return set.makeImmutable(); }) .collect(Collectors.toList()) diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/WorldCalculator.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/WorldCalculator.java index 5c022fd89..32eedfac6 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/WorldCalculator.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/WorldCalculator.java @@ -33,8 +33,6 @@ import me.lucko.luckperms.common.plugin.LuckPermsPlugin; import org.bukkit.entity.Player; -import java.util.Map; - @RequiredArgsConstructor public class WorldCalculator implements ContextCalculator { private static final String WORLD_KEY = "world"; @@ -43,7 +41,8 @@ public class WorldCalculator implements ContextCalculator { @Override public MutableContextSet giveApplicableContext(Player subject, MutableContextSet accumulator) { - String world = getWorld(subject); + String world = subject.getWorld().getName(); + world = plugin.getConfiguration().get(ConfigKeys.WORLD_REWRITES).getOrDefault(world, world); if (world != null) { accumulator.add(Maps.immutableEntry(WORLD_KEY, world)); @@ -51,19 +50,4 @@ public class WorldCalculator implements ContextCalculator { return accumulator; } - - @Override - public boolean isContextApplicable(Player subject, Map.Entry context) { - if (!context.getKey().equals(WORLD_KEY)) { - return false; - } - - String world = getWorld(subject); - return world != null && world.equals(context.getValue()); - } - - private String getWorld(Player player) { - String world = player.getWorld().getName(); - return plugin.getConfiguration().get(ConfigKeys.WORLD_REWRITES).getOrDefault(world, world); - } } diff --git a/bungee/src/main/java/me/lucko/luckperms/bungee/BackendServerCalculator.java b/bungee/src/main/java/me/lucko/luckperms/bungee/BackendServerCalculator.java index 937841711..37755bcda 100644 --- a/bungee/src/main/java/me/lucko/luckperms/bungee/BackendServerCalculator.java +++ b/bungee/src/main/java/me/lucko/luckperms/bungee/BackendServerCalculator.java @@ -29,8 +29,6 @@ import me.lucko.luckperms.api.context.MutableContextSet; import net.md_5.bungee.api.connection.ProxiedPlayer; -import java.util.Map; - public class BackendServerCalculator implements ContextCalculator { private static final String WORLD_KEY = "world"; @@ -48,14 +46,4 @@ public class BackendServerCalculator implements ContextCalculator return accumulator; } - - @Override - public boolean isContextApplicable(ProxiedPlayer subject, Map.Entry context) { - if (!context.getKey().equals(WORLD_KEY)) { - return false; - } - - String server = getServer(subject); - return server != null && server.equals(context.getValue()); - } } diff --git a/bungee/src/main/java/me/lucko/luckperms/bungee/LPBungeePlugin.java b/bungee/src/main/java/me/lucko/luckperms/bungee/LPBungeePlugin.java index a77434be6..e87c56b2f 100644 --- a/bungee/src/main/java/me/lucko/luckperms/bungee/LPBungeePlugin.java +++ b/bungee/src/main/java/me/lucko/luckperms/bungee/LPBungeePlugin.java @@ -38,7 +38,7 @@ import me.lucko.luckperms.common.commands.sender.Sender; import me.lucko.luckperms.common.config.ConfigKeys; import me.lucko.luckperms.common.config.LuckPermsConfiguration; import me.lucko.luckperms.common.contexts.ContextManager; -import me.lucko.luckperms.common.contexts.ServerCalculator; +import me.lucko.luckperms.common.contexts.StaticCalculator; import me.lucko.luckperms.common.core.UuidCache; import me.lucko.luckperms.common.core.model.User; import me.lucko.luckperms.common.dependencies.Dependency; @@ -217,7 +217,7 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin { contextManager = new ContextManager<>(); BackendServerCalculator serverCalculator = new BackendServerCalculator(); contextManager.registerCalculator(serverCalculator); - contextManager.registerCalculator(new ServerCalculator<>(configuration)); + contextManager.registerCalculator(new StaticCalculator<>(configuration)); // register with the LP API getLog().info("Registering API..."); diff --git a/common/src/main/java/me/lucko/luckperms/common/config/AbstractConfiguration.java b/common/src/main/java/me/lucko/luckperms/common/config/AbstractConfiguration.java index 642f33d95..f42375ff9 100644 --- a/common/src/main/java/me/lucko/luckperms/common/config/AbstractConfiguration.java +++ b/common/src/main/java/me/lucko/luckperms/common/config/AbstractConfiguration.java @@ -41,6 +41,9 @@ public abstract class AbstractConfiguration implements LuckPermsConfiguration { @Getter private final LPConfigurationDelegate delegate = new LPConfigurationDelegate(this); + @Getter + private final StaticContextsFile staticContexts = new StaticContextsFile(this); + @SuppressWarnings("unchecked") @Override public T get(ConfigKey key) { @@ -50,6 +53,7 @@ public abstract class AbstractConfiguration implements LuckPermsConfiguration { @Override public void loadAll() { ConfigKeys.getAllKeys().forEach(cache::get); + staticContexts.reload(); } @Override @@ -60,7 +64,7 @@ public abstract class AbstractConfiguration implements LuckPermsConfiguration { cache.invalidateAll(toInvalidate); loadAll(); - + staticContexts.reload(); getPlugin().getApiProvider().getEventFactory().handleConfigReload(); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/config/LuckPermsConfiguration.java b/common/src/main/java/me/lucko/luckperms/common/config/LuckPermsConfiguration.java index fe5811222..f086be195 100644 --- a/common/src/main/java/me/lucko/luckperms/common/config/LuckPermsConfiguration.java +++ b/common/src/main/java/me/lucko/luckperms/common/config/LuckPermsConfiguration.java @@ -34,6 +34,8 @@ public interface LuckPermsConfiguration { LuckPermsPlugin getPlugin(); + StaticContextsFile getStaticContexts(); + void init(); void reload(); diff --git a/common/src/main/java/me/lucko/luckperms/common/config/StaticContextsFile.java b/common/src/main/java/me/lucko/luckperms/common/config/StaticContextsFile.java new file mode 100644 index 000000000..710dd6e81 --- /dev/null +++ b/common/src/main/java/me/lucko/luckperms/common/config/StaticContextsFile.java @@ -0,0 +1,72 @@ +package me.lucko.luckperms.common.config; + +import lombok.Getter; +import lombok.RequiredArgsConstructor; + +import com.google.common.collect.ImmutableSetMultimap; +import com.google.gson.Gson; +import com.google.gson.GsonBuilder; +import com.google.gson.JsonArray; +import com.google.gson.JsonElement; +import com.google.gson.JsonObject; + +import me.lucko.luckperms.api.context.ImmutableContextSet; + +import java.io.BufferedReader; +import java.io.BufferedWriter; +import java.io.File; +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.util.Map; + +@RequiredArgsConstructor +public class StaticContextsFile { + private final LuckPermsConfiguration configuration; + + @Getter + private ImmutableContextSet contextSet = ImmutableContextSet.empty(); + + public void reload() { + File file = new File(configuration.getPlugin().getConfigDirectory(), "static-contexts.json"); + if (!file.exists()) { + try (BufferedWriter writer = Files.newBufferedWriter(file.toPath(), StandardCharsets.UTF_8)) { + JsonObject template = new JsonObject(); + template.add("context", new JsonObject()); + new GsonBuilder().setPrettyPrinting().create().toJson(template, writer); + } catch (IOException e) { + e.printStackTrace(); + } + contextSet = ImmutableContextSet.empty(); + return; + } + + try (BufferedReader reader = Files.newBufferedReader(file.toPath(), StandardCharsets.UTF_8)) { + JsonObject data = new Gson().fromJson(reader, JsonObject.class); + + if (!data.has("context") || !data.get("context").isJsonObject()) { + return; + } + + JsonObject contexts = data.get("context").getAsJsonObject(); + ImmutableSetMultimap.Builder map = ImmutableSetMultimap.builder(); + + for (Map.Entry e : contexts.entrySet()) { + JsonElement val = e.getValue(); + if (val.isJsonArray()) { + JsonArray vals = val.getAsJsonArray(); + for (JsonElement element : vals) { + map.put(e.getKey(), element.getAsString()); + } + } else { + map.put(e.getKey(), val.getAsString()); + } + } + + contextSet = ImmutableContextSet.fromMultimap(map.build()); + } catch (IOException e) { + e.printStackTrace(); + } + } + +} diff --git a/common/src/main/java/me/lucko/luckperms/common/contexts/ServerCalculator.java b/common/src/main/java/me/lucko/luckperms/common/contexts/StaticCalculator.java similarity index 85% rename from common/src/main/java/me/lucko/luckperms/common/contexts/ServerCalculator.java rename to common/src/main/java/me/lucko/luckperms/common/contexts/StaticCalculator.java index 48d17161b..1e4bec421 100644 --- a/common/src/main/java/me/lucko/luckperms/common/contexts/ServerCalculator.java +++ b/common/src/main/java/me/lucko/luckperms/common/contexts/StaticCalculator.java @@ -29,10 +29,8 @@ import me.lucko.luckperms.api.context.MutableContextSet; import me.lucko.luckperms.common.config.ConfigKeys; import me.lucko.luckperms.common.config.LuckPermsConfiguration; -import java.util.Map; - @AllArgsConstructor -public class ServerCalculator implements ContextCalculator { +public class StaticCalculator implements ContextCalculator { private final LuckPermsConfiguration config; @Override @@ -41,11 +39,10 @@ public class ServerCalculator implements ContextCalculator { if (!server.equals("global")) { accumulator.add("server", server); } + + accumulator.addAll(config.getStaticContexts().getContextSet()); + return accumulator; } - @Override - public boolean isContextApplicable(T subject, Map.Entry context) { - return context.getKey().equals("server") && config.get(ConfigKeys.SERVER).equalsIgnoreCase(context.getValue()); - } } diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/LPSpongePlugin.java b/sponge/src/main/java/me/lucko/luckperms/sponge/LPSpongePlugin.java index c32aa8858..d6116f255 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/LPSpongePlugin.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/LPSpongePlugin.java @@ -39,7 +39,7 @@ import me.lucko.luckperms.common.config.ConfigKeys; import me.lucko.luckperms.common.config.LuckPermsConfiguration; import me.lucko.luckperms.common.constants.Permission; import me.lucko.luckperms.common.contexts.ContextManager; -import me.lucko.luckperms.common.contexts.ServerCalculator; +import me.lucko.luckperms.common.contexts.StaticCalculator; import me.lucko.luckperms.common.core.UuidCache; import me.lucko.luckperms.common.core.model.User; import me.lucko.luckperms.common.dependencies.DependencyManager; @@ -265,7 +265,7 @@ public class LPSpongePlugin implements LuckPermsPlugin { cachedStateManager = new CachedStateManager(this); contextManager = new ContextManager<>(); - contextManager.registerCalculator(new ServerCalculator<>(configuration)); + contextManager.registerCalculator(new StaticCalculator<>(configuration)); contextManager.registerCalculator(new WorldCalculator()); // register the PermissionService with Sponge diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/contexts/SpongeCalculatorLink.java b/sponge/src/main/java/me/lucko/luckperms/sponge/contexts/SpongeCalculatorLink.java index 2bce1bef6..268b0862c 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/contexts/SpongeCalculatorLink.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/contexts/SpongeCalculatorLink.java @@ -32,7 +32,6 @@ import org.spongepowered.api.service.context.Context; import org.spongepowered.api.service.permission.Subject; import java.util.HashSet; -import java.util.Map; import java.util.Set; @AllArgsConstructor @@ -47,10 +46,4 @@ public class SpongeCalculatorLink implements ContextCalculator { accumulator.addAll(Util.convertContexts(contexts)); return accumulator; } - - @Override - public boolean isContextApplicable(Subject subject, Map.Entry context) { - Context c = new Context(context.getKey(), context.getValue()); - return calculator.matches(c, subject); - } } diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/contexts/WorldCalculator.java b/sponge/src/main/java/me/lucko/luckperms/sponge/contexts/WorldCalculator.java index d4f75be45..dd1b0c45f 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/contexts/WorldCalculator.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/contexts/WorldCalculator.java @@ -32,8 +32,6 @@ import org.spongepowered.api.entity.living.player.Player; import org.spongepowered.api.service.context.Context; import org.spongepowered.api.service.permission.Subject; -import java.util.Map; - @RequiredArgsConstructor public class WorldCalculator implements ContextCalculator { @@ -49,15 +47,4 @@ public class WorldCalculator implements ContextCalculator { return accumulator; } - @Override - public boolean isContextApplicable(Subject subject, Map.Entry context) { - CommandSource source = subject.getCommandSource().orElse(null); - if (source == null || !(source instanceof Player)) { - return false; - } - - Player p = ((Player) source); - return context.getKey().equals(Context.WORLD_KEY) && p.getWorld().getName().equals(context.getValue()); - } - }