diff --git a/src/main/java/net/minecraft/server/management/ServerConfigurationManager.java b/src/main/java/net/minecraft/server/management/ServerConfigurationManager.java index d58bccd..ffdc068 100644 --- a/src/main/java/net/minecraft/server/management/ServerConfigurationManager.java +++ b/src/main/java/net/minecraft/server/management/ServerConfigurationManager.java @@ -71,7 +71,6 @@ import org.ultramine.permission.MinecraftPermissions; import org.ultramine.server.ConfigurationHandler; import org.ultramine.server.PermissionHandler; -import org.ultramine.permission.internal.OpPermissionProxySet; import org.ultramine.server.chunk.IChunkLoadCallback; import org.ultramine.server.data.ServerDataLoader; import org.ultramine.server.util.WarpLocation; diff --git a/src/main/java/org/ultramine/permission/DummyPermission.java b/src/main/java/org/ultramine/permission/DummyPermission.java index b184024..c59f1d8 100644 --- a/src/main/java/org/ultramine/permission/DummyPermission.java +++ b/src/main/java/org/ultramine/permission/DummyPermission.java @@ -1,8 +1,8 @@ package org.ultramine.permission; +import org.ultramine.permission.internal.AbstractResolver; import org.ultramine.permission.internal.CheckResult; import org.ultramine.permission.internal.MetaResolver; -import org.ultramine.permission.internal.PermissionResolver; public class DummyPermission implements IPermission { @@ -46,7 +46,7 @@ } @Override - public void mergePermissionsTo(PermissionResolver resolver) + public void mergePermissionsTo(AbstractResolver resolver) { resolver.merge(getKey(), (Boolean)true, Integer.MAX_VALUE); } diff --git a/src/main/java/org/ultramine/permission/GroupPermission.java b/src/main/java/org/ultramine/permission/GroupPermission.java deleted file mode 100644 index 02b11f0..0000000 --- a/src/main/java/org/ultramine/permission/GroupPermission.java +++ /dev/null @@ -1,95 +0,0 @@ -package org.ultramine.permission; - -import org.ultramine.permission.internal.MetaResolver; -import org.ultramine.permission.internal.PermissionHolder; -import org.ultramine.permission.internal.PermissionResolver; - -import java.util.ArrayList; -import java.util.List; -import java.util.Map; - -public class GroupPermission extends PermissionHolder implements IPermission -{ - private final String key; - private final List listeners = new ArrayList(); - - public GroupPermission(String key) - { - super(); - this.key = key.toLowerCase(); - } - - public GroupPermission(String key, Map meta) - { - super(meta); - this.key = key.toLowerCase(); - } - - @Override - public String getKey() - { - return key; - } - - @Override - public void mergePermissionsTo(PermissionResolver resolver) - { - resolver.merge(getPermissionResolver(), getPriority()); - } - - @Override - public void mergeMetaTo(MetaResolver resolver) - { - resolver.merge(getMetaResolver(), getPriority()); - } - - @Override - public void subscribe(IDirtyListener listener) - { - listeners.add(listener); - } - - @Override - public void unsubscribe(IDirtyListener listener) - { - listeners.remove(listener); - } - - @Override - public void makeDirty() - { - if (isDirty()) - return; - - super.makeDirty(); - for (IDirtyListener listener : listeners) - listener.makeDirty(); - } - - @Override - public void calculate() - { - super.calculate(); - getPermissionResolver().merge(key, true, Integer.MAX_VALUE); - } - - private int getPriority() - { - return getMetaResolver().getInt("priority"); - } - - @Override - public int hashCode() - { - return getKey().hashCode(); - } - - @Override - public boolean equals(Object obj) - { - if (obj instanceof IPermission) - return getKey().equals(((IPermission) obj).getKey()); - - return super.equals(obj); - } -} diff --git a/src/main/java/org/ultramine/permission/IPermission.java b/src/main/java/org/ultramine/permission/IPermission.java index 584daf5..f0ff956 100644 --- a/src/main/java/org/ultramine/permission/IPermission.java +++ b/src/main/java/org/ultramine/permission/IPermission.java @@ -1,8 +1,8 @@ package org.ultramine.permission; +import org.ultramine.permission.internal.AbstractResolver; import org.ultramine.permission.internal.CheckResult; import org.ultramine.permission.internal.MetaResolver; -import org.ultramine.permission.internal.PermissionResolver; public interface IPermission { @@ -10,7 +10,7 @@ public CheckResult check(String key); public String getMeta(String key); - public void mergePermissionsTo(PermissionResolver resolver); + public void mergePermissionsTo(AbstractResolver resolver); public void mergeMetaTo(MetaResolver resolver); public void subscribe(IDirtyListener listener); diff --git a/src/main/java/org/ultramine/permission/IPermissionContainer.java b/src/main/java/org/ultramine/permission/IPermissionContainer.java new file mode 100644 index 0000000..ee0e17c --- /dev/null +++ b/src/main/java/org/ultramine/permission/IPermissionContainer.java @@ -0,0 +1,12 @@ +package org.ultramine.permission; + +import org.ultramine.permission.internal.CheckResult; + +public interface IPermissionContainer +{ + String getName(); + + CheckResult check(String worldname, String permissionKey); + + String getMeta(String worldname, String key); +} diff --git a/src/main/java/org/ultramine/permission/IPermissionManager.java b/src/main/java/org/ultramine/permission/IPermissionManager.java index 7612670..2e5c083 100644 --- a/src/main/java/org/ultramine/permission/IPermissionManager.java +++ b/src/main/java/org/ultramine/permission/IPermissionManager.java @@ -1,36 +1,39 @@ package org.ultramine.permission; -import org.ultramine.permission.internal.UserContainer; - public interface IPermissionManager { + public static final String GLOBAL_WORLD = "global"; + public static final String DEFAULT_GROUP_NAME = "default"; + public boolean has(String world, String player, String permission); public void add(String world, String player, String permission); - public void addToWorld(String world, String permission); + public void addToMixin(String mixin, String permission); - public void addToGroup(String group, String permission); + public void addToGroup(String group, String world, String permission); public void remove(String world, String player, String permission); - public void removeFromWorld(String world, String permission); + public void removeFromMixin(String mixin, String permission); - public void removeFromGroup(String group, String permission); + public void removeFromGroup(String group, String world, String permission); public String getMeta(String world, String player, String key); public void setMeta(String world, String player, String key, String value); - public void setWorldMeta(String world, String key, String value); + public void setMixinMeta(String mixin, String key, String value); - public void setGroupMeta(String group, String key, String value); + public void setGroupMeta(String group, String world, String key, String value); + + public void setUserGroup(String user, String group); + + public void setGroupInherits(String group, String parent); public void save(); public void reload(); public PermissionRepository getRepository(); - - public UserContainer getWorldContainer(String world); } \ No newline at end of file diff --git a/src/main/java/org/ultramine/permission/MixinPermission.java b/src/main/java/org/ultramine/permission/MixinPermission.java new file mode 100644 index 0000000..94c8a9d --- /dev/null +++ b/src/main/java/org/ultramine/permission/MixinPermission.java @@ -0,0 +1,102 @@ +package org.ultramine.permission; + +import org.ultramine.permission.internal.AbstractResolver; +import org.ultramine.permission.internal.MetaResolver; +import org.ultramine.permission.internal.PermissionHolder; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; + +public class MixinPermission extends PermissionHolder implements IPermission +{ + private final String key; + private final List listeners = new ArrayList(); + private int priority = Integer.MIN_VALUE; + + public MixinPermission(String key) + { + super(); + this.key = key.toLowerCase(); + } + + public MixinPermission(String key, int priority) + { + this(key); + this.priority = priority; + } + + public MixinPermission(String key, Map meta) + { + super(meta); + this.key = key.toLowerCase(); + } + + @Override + public String getKey() + { + return key; + } + + @Override + public void mergePermissionsTo(AbstractResolver resolver) + { + resolver.merge(getPermissionResolver(), getPriority()); + } + + @Override + public void mergeMetaTo(MetaResolver resolver) + { + resolver.merge(getMetaResolver(), getPriority()); + } + + @Override + public void subscribe(IDirtyListener listener) + { + listeners.add(listener); + } + + @Override + public void unsubscribe(IDirtyListener listener) + { + listeners.remove(listener); + } + + @Override + public void makeDirty() + { + if (isDirty()) + return; + + super.makeDirty(); + for (IDirtyListener listener : listeners) + listener.makeDirty(); + } + + @Override + public void calculate() + { + super.calculate(); + getPermissionResolver().merge(key, true, Integer.MAX_VALUE); + } + + private int getPriority() + { + return priority != Integer.MIN_VALUE ? priority : getMetaResolver().getInt("priority"); + } + + @Override + public int hashCode() + { + return getKey().hashCode(); + } + + @Override + public boolean equals(Object obj) + { + if (obj instanceof IPermission) + return getKey().equals(((IPermission) obj).getKey()); + + return super.equals(obj); + } +} diff --git a/src/main/java/org/ultramine/permission/NegativePermission.java b/src/main/java/org/ultramine/permission/NegativePermission.java index bc59143..e4a7df2 100644 --- a/src/main/java/org/ultramine/permission/NegativePermission.java +++ b/src/main/java/org/ultramine/permission/NegativePermission.java @@ -1,8 +1,8 @@ package org.ultramine.permission; +import org.ultramine.permission.internal.AbstractResolver; import org.ultramine.permission.internal.CheckResult; import org.ultramine.permission.internal.MetaResolver; -import org.ultramine.permission.internal.PermissionResolver; class NegativePermission extends PermissionRepository.ProxyPermission { @@ -33,9 +33,9 @@ } @Override - public void mergePermissionsTo(final PermissionResolver resolver) + public void mergePermissionsTo(final AbstractResolver resolver) { - super.mergePermissionsTo(new PermissionResolver() + super.mergePermissionsTo(new AbstractResolver() { @Override public boolean merge(String key, Boolean value, int priority) diff --git a/src/main/java/org/ultramine/permission/PermissionRepository.java b/src/main/java/org/ultramine/permission/PermissionRepository.java index f7c5abe..95f121a 100644 --- a/src/main/java/org/ultramine/permission/PermissionRepository.java +++ b/src/main/java/org/ultramine/permission/PermissionRepository.java @@ -1,8 +1,8 @@ package org.ultramine.permission; +import org.ultramine.permission.internal.AbstractResolver; import org.ultramine.permission.internal.CheckResult; import org.ultramine.permission.internal.MetaResolver; -import org.ultramine.permission.internal.PermissionResolver; import java.util.ArrayList; import java.util.HashMap; @@ -11,16 +11,19 @@ public class PermissionRepository { - private Map proxyPermissions; + private final Map proxyPermissions; + private final Map proxyContainers; public PermissionRepository() { proxyPermissions = new HashMap(); + proxyContainers = new HashMap(); } public PermissionRepository(PermissionRepository anotherRepository) { proxyPermissions = new HashMap(anotherRepository.proxyPermissions); + proxyContainers = new HashMap(anotherRepository.proxyContainers); } public ProxyPermission getPermission(String key) @@ -68,6 +71,26 @@ for (String permission : permissions) getPermission(permission).lock(); } + + public IPermissionContainer getContainer(String name) + { + IPermissionContainer container = proxyContainers.get(name); + if(container == null) + proxyContainers.put(name, container = new ProxyContainer(name)); + return container; + } + + public void registerContainer(String name, IPermissionContainer container) + { + IPermissionContainer old = proxyContainers.get(name); + if(old == null) + proxyContainers.put(name, container); + else if(old instanceof ProxyContainer) + ((ProxyContainer)old).link(container); + else + throw new IllegalArgumentException("Container already registered"); + + } public static class ProxyPermission implements IPermission { @@ -117,7 +140,7 @@ } @Override - public void mergePermissionsTo(PermissionResolver resolver) + public void mergePermissionsTo(AbstractResolver resolver) { wrappedPermission.mergePermissionsTo(resolver); } @@ -181,4 +204,38 @@ return wrappedPermission.toString(); } } + + private static class ProxyContainer implements IPermissionContainer + { + private final String name; + private IPermissionContainer wrappedContainer; + + private ProxyContainer(String name) + { + this.name = name; + } + + @Override + public String getName() + { + return name; + } + + @Override + public CheckResult check(String worldname, String permissionKey) + { + return wrappedContainer != null ? wrappedContainer.check(worldname, permissionKey) : CheckResult.UNRESOLVED; + } + + @Override + public String getMeta(String worldname, String key) + { + return wrappedContainer != null ? wrappedContainer.getMeta(worldname, key) : null; + } + + private void link(IPermissionContainer container) + { + this.wrappedContainer = container; + } + } } \ No newline at end of file diff --git a/src/main/java/org/ultramine/permission/User.java b/src/main/java/org/ultramine/permission/User.java deleted file mode 100644 index 80c9f4b..0000000 --- a/src/main/java/org/ultramine/permission/User.java +++ /dev/null @@ -1,27 +0,0 @@ -package org.ultramine.permission; - -import org.ultramine.permission.internal.PermissionHolder; - -import java.util.Map; - -public class User extends PermissionHolder -{ - private final String name; - - public User(String name) - { - super(); - this.name = name.toLowerCase(); - } - - public User(String name, Map meta) - { - super(meta); - this.name = name.toLowerCase(); - } - - public String getName() - { - return name; - } -} \ No newline at end of file diff --git a/src/main/java/org/ultramine/permission/World.java b/src/main/java/org/ultramine/permission/World.java deleted file mode 100644 index c324112..0000000 --- a/src/main/java/org/ultramine/permission/World.java +++ /dev/null @@ -1,121 +0,0 @@ -package org.ultramine.permission; - -import org.ultramine.permission.internal.CheckResult; -import org.ultramine.permission.internal.PermissionHolder; -import org.ultramine.permission.internal.UserContainer; - -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - -public class World extends UserContainer -{ - private GroupPermission defaultGroup; - - public World() - { - this.defaultGroup = new GroupPermission(""); - } - - public void load(PermissionRepository repository, WorldData data) - { - if (data == null) - return; - - defaultGroup = new GroupPermission(""); - if (data.default_group != null) - { - if (data.default_group.meta != null) - defaultGroup.setInnerMeta(data.default_group.meta); - - if (data.default_group.permissions != null) - { - for (String permission : data.default_group.permissions) - defaultGroup.addPermission(repository.getPermission(permission)); - } - } - - clear(); - if (data.users == null) - return; - - for (Map.Entry userData : data.users.entrySet()) - { - User user = new User(userData.getKey(), userData.getValue().meta); - for (String permission : userData.getValue().permissions) - user.addPermission(repository.getPermission(permission)); - add(user); - } - } - - public WorldData save() - { - WorldData data = new WorldData(); - - data.default_group = new HolderData(defaultGroup); - data.users = new HashMap(users.size()); - - for (User user : users.values()) - { - HolderData holderData = new HolderData(user); - if (!holderData.isEmpty()) - data.users.put(user.getName(), new HolderData(user)); - } - - return data; - } - - public GroupPermission getDefaultGroup() - { - return defaultGroup; - } - - public void setParentContainer(UserContainer container) - { - parentContainer = container; - } - - @Override - public String getUserMeta(String userName, String metaKey) - { - String result = super.getUserMeta(userName, metaKey); - return result.isEmpty() ? defaultGroup.getMeta(metaKey) : result; - } - - @Override - protected CheckResult check(String userName, String permissionKey) - { - CheckResult result = super.check(userName, permissionKey); - return result == CheckResult.UNRESOLVED ? defaultGroup.check(permissionKey) : result; - } - - public static class WorldData - { - public HolderData default_group = new HolderData(); - public Map users = new HashMap(); - } - - public static class HolderData - { - public List permissions; - public Map meta; - - public HolderData() - { - permissions = new ArrayList(); - meta = new HashMap(); - } - - public HolderData(PermissionHolder holder) - { - permissions = holder.getInnerPermissions(); - meta = holder.getInnerMeta(); - } - - public boolean isEmpty() - { - return permissions.isEmpty() && meta.isEmpty(); - } - } -} diff --git a/src/main/java/org/ultramine/permission/commands/BasicPermissionCommands.java b/src/main/java/org/ultramine/permission/commands/BasicPermissionCommands.java index 698366a..fd41e5f 100644 --- a/src/main/java/org/ultramine/permission/commands/BasicPermissionCommands.java +++ b/src/main/java/org/ultramine/permission/commands/BasicPermissionCommands.java @@ -2,7 +2,7 @@ import org.ultramine.commands.Command; import org.ultramine.commands.CommandContext; -import org.ultramine.permission.internal.ServerPermissionManager; +import org.ultramine.permission.IPermissionManager; import org.ultramine.server.PermissionHandler; public class BasicPermissionCommands @@ -14,113 +14,68 @@ permissions = {"permissions.admin"}, syntax = {"[save reload]"} ) - public static void pcofnig(CommandContext context) + public static void pcofnig(CommandContext ctx) { - if (context.actionIs("save")) + if (ctx.actionIs("save")) { PermissionHandler.getInstance().save(); - context.notifyAdmins("command.pconfig.success.save"); + ctx.notifyAdmins("command.pconfig.success.save"); } else { PermissionHandler.getInstance().reload(); - context.notifyAdmins("command.pconfig.success.reload"); + ctx.notifyAdmins("command.pconfig.success.reload"); } } - - - @Command( - name = "pworld", - group = "permissions", - permissions = {"permissions.admin.world"}, - syntax = { - "[add remove] ...", - "[meta] <%value>", - " [add remove] ...", - " [meta] <%value>", - } - ) - public static void pworld(CommandContext context) - { - String world = context.contains("world") - ? context.get("world").asWorld().getWorldInfo().getWorldName() - : ServerPermissionManager.GLOBAL_WORLD; - - context.checkSenderPermissionInWorld(world, "permissions.admin.world"); - - if (context.actionIs("add")) - { - for (CommandContext.Argument arg : context.get("permission").asArray()) - { - PermissionHandler.getInstance().addToWorld(world, arg.asString()); - context.notifyAdmins("command.pworld.success.add", arg.asString(), world); - } - } - else if (context.actionIs("remove")) - { - for (CommandContext.Argument arg : context.get("permission").asArray()) - { - PermissionHandler.getInstance().removeFromWorld(world, arg.asString()); - context.notifyAdmins("command.pworld.success.remove", arg.asString(), world); - } - } - else - { - String key = context.get("pmeta").asString(); - String value = context.get("value").asString(); - - PermissionHandler.getInstance().setWorldMeta(world, key, value); - context.notifyAdmins("command.pworld.success.meta", key, value, world); - } - - PermissionHandler.getInstance().save(); - } - - @Command( name = "puser", group = "permissions", permissions = {"permissions.admin.user"}, syntax = { + " [setgroup] ", " [add remove] ...", " [meta] <%value>", " [add remove] ...", " [meta] <%value>" } ) - public static void puser(CommandContext context) + public static void puser(CommandContext ctx) { - String player = context.get("player").asString(); - String world = context.contains("world") - ? context.get("world").asWorld().getWorldInfo().getWorldName() - : ServerPermissionManager.GLOBAL_WORLD; + String player = ctx.get("player").asString(); + String world = ctx.contains("world") + ? ctx.get("world").asWorld().getWorldInfo().getWorldName() + : IPermissionManager.GLOBAL_WORLD; - context.checkSenderPermissionInWorld(world, "permissions.admin.world"); + ctx.checkSenderPermissionInWorld(world, "permissions.admin.world"); - if (context.actionIs("add")) + if (ctx.actionIs("setgroup")) { - for (CommandContext.Argument arg : context.get("permission").asArray()) + PermissionHandler.getInstance().setUserGroup(player, ctx.get("group").asString()); + } + else if (ctx.actionIs("add")) + { + for (CommandContext.Argument arg : ctx.get("permission").asArray()) { PermissionHandler.getInstance().add(world, player, arg.asString()); - context.notifyAdmins("command.puser.success.add", arg.asString(), player, world); + ctx.notifyAdmins("command.puser.success.add", arg.asString(), player, world); } } - else if (context.actionIs("remove")) + else if (ctx.actionIs("remove")) { - for (CommandContext.Argument arg : context.get("permission").asArray()) + for (CommandContext.Argument arg : ctx.get("permission").asArray()) { PermissionHandler.getInstance().remove(world, player, arg.asString()); - context.notifyAdmins("command.puser.success.remove", arg.asString(), player, world); + ctx.notifyAdmins("command.puser.success.remove", arg.asString(), player, world); } } else { - String key = context.get("pmeta").asString(); - String value = context.get("value").asString(); + String key = ctx.get("pmeta").asString(); + String value = ctx.get("value").asString(); PermissionHandler.getInstance().setMeta(world, player, key, value); - context.notifyAdmins("command.puser.success.meta", key, value, player, world); + ctx.notifyAdmins("command.puser.success.meta", key, value, player, world); } PermissionHandler.getInstance().save(); @@ -128,40 +83,90 @@ @Command( - name = "pgroup", + name = "pmixin", group = "permissions", - permissions = {"permissions.admin.group"}, + permissions = {"permissions.admin.mixin"}, syntax = { - " [add remove] ...", - " [meta] <%value>" + " [add remove] ...", + " [meta] <%value>" } ) - public static void pgroup(CommandContext context) + public static void pmixin(CommandContext ctx) { - String group = context.get("group").asString(); + String mixin = ctx.get("mixin").asString(); - if (context.actionIs("add")) + if (ctx.actionIs("add")) { - for (CommandContext.Argument arg : context.get("permission").asArray()) + for (CommandContext.Argument arg : ctx.get("permission").asArray()) { - PermissionHandler.getInstance().addToGroup(group, arg.asString()); - context.notifyAdmins("command.pgroup.success.add", arg.asString(), group); + PermissionHandler.getInstance().addToMixin(mixin, arg.asString()); + ctx.notifyAdmins("command.pgroup.success.add", arg.asString(), mixin); } } - else if (context.actionIs("remove")) + else if (ctx.actionIs("remove")) { - for (CommandContext.Argument arg : context.get("permission").asArray()) + for (CommandContext.Argument arg : ctx.get("permission").asArray()) { - PermissionHandler.getInstance().removeFromGroup(group, arg.asString()); - context.notifyAdmins("command.pgroup.success.remove", arg.asString(), group); + PermissionHandler.getInstance().removeFromMixin(mixin, arg.asString()); + ctx.notifyAdmins("command.pgroup.success.remove", arg.asString(), mixin); } } else { - String key = context.get("key").asString(); - String value = context.get("value").asString(); - PermissionHandler.getInstance().setGroupMeta(group, key, value); - context.notifyAdmins("command.pgroup.success.meta", key, value, group); + String key = ctx.get("key").asString(); + String value = ctx.get("value").asString(); + PermissionHandler.getInstance().setMixinMeta(mixin, key, value); + ctx.notifyAdmins("command.pgroup.success.meta", key, value, mixin); + } + + PermissionHandler.getInstance().save(); + } + + @Command( + name = "pgroup", + group = "permissions", + permissions = {"permissions.admin.group"}, + syntax = { + " [setparent] ", + " [add remove] ...", + " [meta] <%value>", + " [add remove] ...", + " [meta] <%value>" + } + ) + public static void pgroup(CommandContext ctx) + { + String group = ctx.get("group").asString(); + String world = ctx.contains("world") + ? ctx.getServer().getMultiWorld().getNameByID(ctx.get("world").asWorld().provider.dimensionId) + : IPermissionManager.GLOBAL_WORLD; + + if (ctx.actionIs("setparent")) + { + PermissionHandler.getInstance().setUserGroup(group, ctx.get("parent").asString()); + } + if (ctx.actionIs("add")) + { + for (CommandContext.Argument arg : ctx.get("permission").asArray()) + { + PermissionHandler.getInstance().addToGroup(group, world, arg.asString()); + ctx.notifyAdmins("command.pgroup.success.add", arg.asString(), group); + } + } + else if (ctx.actionIs("remove")) + { + for (CommandContext.Argument arg : ctx.get("permission").asArray()) + { + PermissionHandler.getInstance().removeFromGroup(group, world, arg.asString()); + ctx.notifyAdmins("command.pgroup.success.remove", arg.asString(), group); + } + } + else + { + String key = ctx.get("key").asString(); + String value = ctx.get("value").asString(); + PermissionHandler.getInstance().setGroupMeta(group, world, key, value); + ctx.notifyAdmins("command.pgroup.success.meta", key, value, group); } PermissionHandler.getInstance().save(); diff --git a/src/main/java/org/ultramine/permission/internal/AbstractResolver.java b/src/main/java/org/ultramine/permission/internal/AbstractResolver.java new file mode 100644 index 0000000..1d5fd6f --- /dev/null +++ b/src/main/java/org/ultramine/permission/internal/AbstractResolver.java @@ -0,0 +1,27 @@ +package org.ultramine.permission.internal; + +import java.util.Map; + +public abstract class AbstractResolver +{ + protected Map getValues() + { + return null; + } + + public final void merge(AbstractResolver anotherResolver, int priority) + { + if (anotherResolver != null) + merge(anotherResolver.getValues(), priority); + } + + public final void merge(Map newValues, int priority) + { + for (Map.Entry entry : newValues.entrySet()) + merge(entry.getKey(), entry.getValue(), priority); + + } + + public abstract boolean merge(String key, T value, int priority); + +} diff --git a/src/main/java/org/ultramine/permission/internal/ClientPermissionManager.java b/src/main/java/org/ultramine/permission/internal/ClientPermissionManager.java index 083d804..737cfa1 100644 --- a/src/main/java/org/ultramine/permission/internal/ClientPermissionManager.java +++ b/src/main/java/org/ultramine/permission/internal/ClientPermissionManager.java @@ -2,11 +2,10 @@ import cpw.mods.fml.relauncher.Side; import cpw.mods.fml.relauncher.SideOnly; -import org.ultramine.permission.GroupPermission; + +import org.ultramine.permission.MixinPermission; import org.ultramine.permission.IPermissionManager; import org.ultramine.permission.PermissionRepository; -import org.ultramine.permission.User; -import org.ultramine.permission.World; import java.util.HashMap; import java.util.Map; @@ -14,99 +13,93 @@ @SideOnly(Side.CLIENT) public class ClientPermissionManager implements IPermissionManager { - private static final String[] DEFAULT_PERMISSIONS = new String[] { - "command.vanilla.seed", "command.vanilla.tell", "command.vanilla.help", "command.vanilla.me" - }; - - private World global; private PermissionRepository permissionRepository; - private Map groups; + private Map groups; private String owner; public ClientPermissionManager(String owner, PermissionRepository permissionRepository) { this.permissionRepository = permissionRepository; - this.global = new World(); - this.groups = new HashMap(); + this.groups = new HashMap(); this.owner = owner; - - for (String permission : DEFAULT_PERMISSIONS) - global.getDefaultGroup().addPermission(permissionRepository.getPermission(permission)); } @Override public boolean has(String world, String player, String permission) { - return player.equalsIgnoreCase(owner) || global.checkUserPermission(player, permission); + return player.equalsIgnoreCase(owner); } @Override public void add(String world, String player, String permission) { - getOrCreateUser(player).addPermission(permissionRepository.getPermission(permission)); + } @Override - public void addToWorld(String world, String permission) + public void addToMixin(String group, String permission) { - global.getDefaultGroup().addPermission(permissionRepository.getPermission(permission)); + } @Override - public void addToGroup(String group, String permission) + public void addToGroup(String group, String world, String permission) { - getOrCreateGroup(group).addPermission(permissionRepository.getPermission(permission)); + } @Override public void remove(String world, String player, String permission) { - User user = global.get(player); - if (user == null) - return; - - user.removePermission(permission); + } @Override - public void removeFromWorld(String world, String permission) + public void removeFromMixin(String group, String permission) { - global.getDefaultGroup().removePermission(permission); + } @Override - public void removeFromGroup(String group, String permission) + public void removeFromGroup(String group, String world, String permission) { - GroupPermission groupObj = groups.get(ServerPermissionManager.fixGroupKey(group)); - groupObj.removePermission(permission); + } @Override public String getMeta(String world, String player, String key) { - User user = global.get(player); - if (user == null) - return ""; - else - return user.getMeta(key); + return ""; } @Override public void setMeta(String world, String player, String key, String value) { - getOrCreateUser(player).setMeta(key, value); + } @Override - public void setWorldMeta(String world, String key, String value) + public void setMixinMeta(String group, String key, String value) { - global.getDefaultGroup().setMeta(key, value); + } @Override - public void setGroupMeta(String group, String key, String value) + public void setGroupMeta(String group, String world, String key, String value) { - getOrCreateGroup(group).setMeta(key, value); + + } + + @Override + public void setUserGroup(String user, String group) + { + + } + + @Override + public void setGroupInherits(String group, String parent) + { + } @Override @@ -124,36 +117,4 @@ { return permissionRepository; } - - @Override - public UserContainer getWorldContainer(String world) - { - return global; - } - - private User getOrCreateUser(String name) - { - User user = global.get(name); - if (user == null) - { - user = new User(name); - global.add(user); - } - - return user; - } - - private GroupPermission getOrCreateGroup(String name) - { - String groupKey = ServerPermissionManager.fixGroupKey(name); - GroupPermission group = groups.get(groupKey); - if (group == null) - { - group = new GroupPermission(groupKey); - permissionRepository.registerPermission(group); - groups.put(groupKey, group); - } - - return group; - } } diff --git a/src/main/java/org/ultramine/permission/internal/MetaHolder.java b/src/main/java/org/ultramine/permission/internal/MetaHolder.java index 7c2dc6d..77a2560 100644 --- a/src/main/java/org/ultramine/permission/internal/MetaHolder.java +++ b/src/main/java/org/ultramine/permission/internal/MetaHolder.java @@ -1,6 +1,6 @@ package org.ultramine.permission.internal; -import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.Map; public abstract class MetaHolder @@ -9,7 +9,7 @@ public MetaHolder() { - innerMeta = new HashMap(); + innerMeta = new LinkedHashMap(); } public MetaHolder(Map meta) @@ -39,12 +39,12 @@ public Map getInnerMeta() { - return new HashMap(innerMeta); + return new LinkedHashMap(innerMeta); } public void setInnerMeta(Map meta) { - innerMeta = new HashMap(meta); + innerMeta = new LinkedHashMap(meta); } protected abstract MetaResolver getMetaResolver(); diff --git a/src/main/java/org/ultramine/permission/internal/MetaResolver.java b/src/main/java/org/ultramine/permission/internal/MetaResolver.java index 76baea7..b5ed74b 100644 --- a/src/main/java/org/ultramine/permission/internal/MetaResolver.java +++ b/src/main/java/org/ultramine/permission/internal/MetaResolver.java @@ -11,10 +11,7 @@ public String getString(String key) { - if (values.containsKey(key)) - return values.get(key); - else - return ""; + return values.get(key); } public int getInt(String key) diff --git a/src/main/java/org/ultramine/permission/internal/OpPermissionProxySet.java b/src/main/java/org/ultramine/permission/internal/OpPermissionProxySet.java deleted file mode 100644 index 90b9a62..0000000 --- a/src/main/java/org/ultramine/permission/internal/OpPermissionProxySet.java +++ /dev/null @@ -1,119 +0,0 @@ -package org.ultramine.permission.internal; - -import org.ultramine.server.PermissionHandler; - -import java.util.Collection; -import java.util.Iterator; -import java.util.Set; - -/** - * Never use it! For backward сompatibility only. - */ -@Deprecated -public class OpPermissionProxySet implements Set -{ - public static final OpPermissionProxySet INSTANCE = new OpPermissionProxySet(); - public static final String OP_GROUP = "minecraft.op_group"; - - private OpPermissionProxySet() - { - } - - @Override - public int size() - { - return ops().size(); - } - - @Override - public boolean isEmpty() - { - return ops().isEmpty(); - } - - @Override - public boolean contains(Object o) - { - return PermissionHandler.getInstance().hasGlobally((String)o, OP_GROUP); - } - - @Override - public Iterator iterator() - { - return ops().iterator(); - } - - @Override - public Object[] toArray() - { - return ops().toArray(); - } - - @Override - public T[] toArray(T[] a) - { - return ops().toArray(a); - } - - @Override - public boolean add(String s) - { - PermissionHandler.getInstance().add(ServerPermissionManager.GLOBAL_WORLD, s, OP_GROUP); - return true; - } - - @Override - public boolean remove(Object o) - { - PermissionHandler.getInstance().remove(ServerPermissionManager.GLOBAL_WORLD, o.toString(), OP_GROUP); - return true; - } - - @Override - public boolean containsAll(Collection c) - { - return ops().containsAll(c); - } - - @Override - public boolean addAll(Collection c) - { - for (String user : c) - add(user); - return true; - } - - @Override - public boolean retainAll(Collection c) - { - Set ops = ops(); - for (String user : ops) - { - if (!c.contains(user)) - remove(user); - } - return true; - } - - @Override - public boolean removeAll(Collection c) - { - for (Object user : c) - remove(user); - return true; - } - - @Override - public void clear() - { - Set ops = ops(); - for (String user : ops) - remove(user); - } - - private Set ops() - { - return PermissionHandler.getInstance() - .getWorldContainer(ServerPermissionManager.GLOBAL_WORLD).getAllWithPermission(OP_GROUP); - } -} diff --git a/src/main/java/org/ultramine/permission/internal/PermUser.java b/src/main/java/org/ultramine/permission/internal/PermUser.java new file mode 100644 index 0000000..25588c5 --- /dev/null +++ b/src/main/java/org/ultramine/permission/internal/PermUser.java @@ -0,0 +1,131 @@ +package org.ultramine.permission.internal; + +import java.util.LinkedHashMap; +import java.util.Map; + +import org.ultramine.permission.IPermission; +import org.ultramine.permission.IPermissionContainer; +import org.ultramine.permission.IPermissionManager; +import org.ultramine.permission.MixinPermission; + +public class PermUser implements IPermissionContainer +{ + private final String name; + private final MixinPermission global = new MixinPermission("global_world_mixin", -1); + private final Map worlds = new LinkedHashMap(); + private IPermissionContainer parentContainer; + + public PermUser(String name) + { + this.name = name; + worlds.put(IPermissionManager.GLOBAL_WORLD, global); + } + + @Override + public String getName() + { + return name; + } + + public void setParent(IPermissionContainer parentContainer) + { + this.parentContainer = parentContainer; + } + + public String getParentName() + { + return parentContainer != null ? parentContainer.getName() : ""; + } + + public boolean checkUserPermission(String worldname, String permissionKey) + { + return check(worldname, permissionKey).asBoolean(); + } + + public CheckResult check(String worldname, String permissionKey) + { + CheckResult result = CheckResult.UNRESOLVED; + + PermissionHolder world = worlds.get(worldname); + if (world == null) + world = global; + + result = world.check(permissionKey); + + if (result == CheckResult.UNRESOLVED && parentContainer != null) + result = parentContainer.check(worldname, permissionKey); + + return result; + } + + @Override + public String getMeta(String worldname, String key) + { + String result = null; + + PermissionHolder world = worlds.get(worldname); + if (world == null) + world = global; + + result = world.getMeta(key); + + if (result == null && parentContainer != null) + result = parentContainer.getMeta(worldname, key); + + return result; + } + + public PermissionHolder getGlobalHolder() + { + return global; + } + + public PermissionHolder getOrCreateWorldHolder(String worldname) + { + PermissionHolder holder = worlds.get(worldname); + if(holder == null) + { + holder = new PermissionHolder(); + holder.addPermission(global); + worlds.put(worldname, holder); + } + return holder; + } + + public void addPermission(String worldname, IPermission permission) + { + getOrCreateWorldHolder(worldname).addPermission(permission); + } + + public void removePermission(String worldname, String key) + { + PermissionHolder holder = worlds.get(worldname); + if(holder != null) + holder.removePermission(key); + } + + public void setMeta(String worldname, String key, String value) + { + getOrCreateWorldHolder(worldname).setMeta(key, value); + } + + public void clearAll() + { + global.clearPermissions(); + global.clearMeta(); + for(PermissionHolder holder : worlds.values()) + { + holder.clearPermissions(); + holder.clearMeta(); + } + worlds.clear(); + worlds.put(IPermissionManager.GLOBAL_WORLD, global); + } + + public Map getInnerWorlds() + { + Map map = new LinkedHashMap(worlds); + map.remove(IPermissionManager.GLOBAL_WORLD); + return map; + } +} diff --git a/src/main/java/org/ultramine/permission/internal/PermissionHolder.java b/src/main/java/org/ultramine/permission/internal/PermissionHolder.java index 2bf7aae..793b3f4 100644 --- a/src/main/java/org/ultramine/permission/internal/PermissionHolder.java +++ b/src/main/java/org/ultramine/permission/internal/PermissionHolder.java @@ -4,7 +4,7 @@ import org.ultramine.permission.IPermission; import java.util.ArrayList; -import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.List; import java.util.Map; @@ -12,7 +12,7 @@ { private boolean dirty; - private Map permissions = new HashMap(); + private Map permissions = new LinkedHashMap(); private PermissionResolver permissionResolver = new PermissionResolver(); private MetaResolver metaResolver = new MetaResolver(); diff --git a/src/main/java/org/ultramine/permission/internal/PermissionResolver.java b/src/main/java/org/ultramine/permission/internal/PermissionResolver.java index 33465ed..a70b76b 100644 --- a/src/main/java/org/ultramine/permission/internal/PermissionResolver.java +++ b/src/main/java/org/ultramine/permission/internal/PermissionResolver.java @@ -4,13 +4,7 @@ public class PermissionResolver extends Resolver { - private SortedMap wildcards; - - public PermissionResolver() - { - super(); - this.wildcards = new TreeMap(Collections.reverseOrder()); - } + private final SortedMap wildcards = new TreeMap(Collections.reverseOrder()); public static PermissionResolver createInverted(PermissionResolver anotherResolver) { @@ -33,9 +27,9 @@ if (key == null) return CheckResult.UNRESOLVED; - key = key.toLowerCase(); - if (values.containsKey(key)) - return CheckResult.fromBoolean(values.get(key)); + Boolean val = values.get(key); + if (val != null) + return CheckResult.fromBoolean(val); if (wildcards.size() > 0) { diff --git a/src/main/java/org/ultramine/permission/internal/Resolver.java b/src/main/java/org/ultramine/permission/internal/Resolver.java index 1966f64..f90eaef 100644 --- a/src/main/java/org/ultramine/permission/internal/Resolver.java +++ b/src/main/java/org/ultramine/permission/internal/Resolver.java @@ -5,15 +5,13 @@ import java.util.HashMap; import java.util.Map; -public class Resolver +public class Resolver extends AbstractResolver { - protected Map values; - protected TObjectIntHashMap priorities; + protected final Map values = new HashMap(); + protected final TObjectIntHashMap priorities = new TObjectIntHashMap(); public Resolver() { - values = new HashMap(); - priorities = new TObjectIntHashMap(); } public void clear() @@ -22,17 +20,9 @@ priorities.clear(); } - public final void merge(Resolver anotherResolver, int priority) + protected Map getValues() { - if (anotherResolver != null) - merge(anotherResolver.values, priority); - } - - public final void merge(Map newValues, int priority) - { - for (Map.Entry entry : newValues.entrySet()) - merge(entry.getKey(), entry.getValue(), priority); - + return values; } public boolean merge(String key, T value, int priority) diff --git a/src/main/java/org/ultramine/permission/internal/ServerPermissionManager.java b/src/main/java/org/ultramine/permission/internal/ServerPermissionManager.java index dec2aae..fd0f30e 100644 --- a/src/main/java/org/ultramine/permission/internal/ServerPermissionManager.java +++ b/src/main/java/org/ultramine/permission/internal/ServerPermissionManager.java @@ -2,28 +2,34 @@ import cpw.mods.fml.relauncher.Side; import cpw.mods.fml.relauncher.SideOnly; -import org.ultramine.permission.GroupPermission; + +import org.ultramine.permission.MixinPermission; import org.ultramine.permission.IPermissionManager; import org.ultramine.permission.PermissionRepository; -import org.ultramine.permission.User; -import org.ultramine.permission.World; import org.ultramine.server.util.YamlConfigProvider; +import com.mysql.jdbc.StringUtils; + import java.io.File; +import java.util.ArrayList; import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.List; import java.util.Map; @SideOnly(Side.SERVER) public class ServerPermissionManager implements IPermissionManager { - public final static String GLOBAL_WORLD = "global"; - private final static String GROUPS_CONFIG = "groups.yml"; - private static final String GROUP_PREFIX = "group."; + private static final String GROUPS_CONFIG = "groups.yml"; + private static final String MIXINS_CONFIG = "mixins.yml"; + private static final String MIXIN_PREFIX = "mixin."; - private File configDir; - private Map worlds; - private PermissionRepository permissionRepository; - private Map groups; + private final File configDir; + private final PermissionRepository permissionRepository; + private final Map mixins = new LinkedHashMap(); + private final Map groups = new LinkedHashMap(); + private final Map users = new LinkedHashMap(); + private final PermUser defaultGroup; public ServerPermissionManager(File configDir, PermissionRepository permissionRepository) { @@ -32,10 +38,7 @@ this.configDir.mkdir(); this.permissionRepository = permissionRepository; - this.worlds = new HashMap(); - this.groups = new HashMap(); - reloadGroups(); - reloadWorld(GLOBAL_WORLD); + defaultGroup = getOrCreateGroup(DEFAULT_GROUP_NAME); } @Override @@ -45,230 +48,279 @@ } @Override - public UserContainer getWorldContainer(String world) - { - return worlds.get(world); - } - - @Override public boolean has(String world, String player, String permission) { - World worldObj = worlds.get(world); - if (worldObj == null) - worldObj = worlds.get(GLOBAL_WORLD); - - return worldObj.checkUserPermission(player, permission); + PermUser user = users.get(player.toLowerCase()); + if(user == null) + user = defaultGroup; + return user.checkUserPermission(world, permission); } @Override public void add(String world, String player, String permission) { - getOrCreateUser(world, player).addPermission(permissionRepository.getPermission(permission)); + getOrCreateUser(player).addPermission(world, permissionRepository.getPermission(permission)); } @Override - public void addToWorld(String world, String permission) + public void addToMixin(String group, String permission) { - getOrCreateWorld(world).getDefaultGroup() - .addPermission(permissionRepository.getPermission(permission)); + getOrCreateMixin(group).addPermission(permissionRepository.getPermission(permission)); } - + @Override - public void addToGroup(String group, String permission) + public void addToGroup(String group, String world, String permission) { - getOrCreateGroup(group).addPermission(permissionRepository.getPermission(permission)); + getOrCreateGroup(group).addPermission(world, permissionRepository.getPermission(permission)); } @Override public void remove(String world, String player, String permission) { - User user = getUser(world, player); + PermUser user = users.get(player.toLowerCase()); if (user == null) return; - user.removePermission(permission); + user.removePermission(world, permission); } @Override - public void removeFromWorld(String world, String permission) + public void removeFromMixin(String mixin, String permission) { - World worldObj = worlds.get(world); - if (worldObj == null) - return; - - worldObj.getDefaultGroup().removePermission(permission); - } - - @Override - public void removeFromGroup(String group, String permission) - { - GroupPermission groupObj = groups.get(fixGroupKey(group)); + MixinPermission groupObj = mixins.get(fixMixinKey(mixin)); if (groupObj == null) return; groupObj.removePermission(permission); } + + @Override + public void removeFromGroup(String group, String world, String permission) + { + getOrCreateGroup(group).removePermission(world, permission); + } @Override public String getMeta(String world, String player, String key) { - World worldObj = worlds.get(world); - if (worldObj == null) - worldObj = worlds.get(GLOBAL_WORLD); + PermUser user = users.get(player.toLowerCase()); + if (user == null) + user = defaultGroup; - return worldObj.getUserMeta(player, key); + String meta = user.getMeta(world, key); + return meta != null ? meta : ""; } @Override + public void setMixinMeta(String group, String key, String value) + { + getOrCreateMixin(group).setMeta(key, value); + } + + @Override + public void setGroupMeta(String group, String world, String key, String value) + { + getOrCreateGroup(group).setMeta(world, key, value); + } + + @Override public void setMeta(String world, String player, String key, String value) { - getOrCreateUser(world, player).setMeta(key, value); + getOrCreateUser(player).setMeta(world, key, value); } @Override - public void setWorldMeta(String world, String key, String value) + public void setUserGroup(String user, String group) { - getOrCreateWorld(world).getDefaultGroup().setMeta(key, value); + getOrCreateUser(user).setParent(permissionRepository.getContainer(group)); } @Override - public void setGroupMeta(String group, String key, String value) + public void setGroupInherits(String group, String parent) { - getOrCreateGroup(group).setMeta(key, value); + getOrCreateGroup(group).setParent(permissionRepository.getContainer(parent)); } @Override public void save() { + saveMixins(); saveGroups(); - for (String world : worlds.keySet()) - saveWorld(world); + saveUsers(); } @Override public void reload() { + reloadMixins(); reloadGroups(); - for (String world : worlds.keySet()) - reloadWorld(world); + reloadUsers(); } - public World reloadWorld(String name) + public void reloadMixins() { - World.WorldData data = YamlConfigProvider.getOrCreateConfig(worldFile(name), World.WorldData.class); - World world = worlds.get(name); - if (world == null) + File file = mixinsFile(); + if(file.exists()) { - world = new World(); - worlds.put(name, world); + for (MixinPermission mixin : mixins.values()) + { + mixin.clearPermissions(); + mixin.clearMeta(); + } + + MixinData data = YamlConfigProvider.getOrCreateConfig(file, MixinData.class); + if (data == null || data.mixins == null) + return; + + for (Map.Entry groupData : data.mixins.entrySet()) + { + MixinPermission mixin = getOrCreateMixin(groupData.getKey()); + mixin.setInnerMeta(groupData.getValue().meta); + + for (String pKey : groupData.getValue().permissions) + mixin.addPermission(permissionRepository.getPermission(pKey)); + } } - - world.load(permissionRepository, data); - - if (!name.equals(GLOBAL_WORLD)) - world.setParentContainer(worlds.get(GLOBAL_WORLD)); - - return world; + else + { + saveMixins(); + } } - public void saveWorld(String name) + public void saveMixins() { - World world = worlds.get(name); - if (world == null) - return; + MixinData data = new MixinData(); - YamlConfigProvider.saveConfig(worldFile(name), world.save()); + for (Map.Entry group : mixins.entrySet()) + data.mixins.put(group.getKey(), new HolderData(group.getValue())); + + YamlConfigProvider.saveConfig(mixinsFile(), data); } public void reloadGroups() { - for (GroupPermission group : groups.values()) + File file = groupsFile(); + if(file.exists()) { - group.clearPermissions(); - group.clearMeta(); + for(PermUser group : groups.values()) + group.clearAll(); + + GroupsData data = YamlConfigProvider.getOrCreateConfig(file, GroupsData.class); + for(Map.Entry groupData : data.groups.entrySet()) + fillContainer(getOrCreateGroup(groupData.getKey()), groupData.getValue()); } - - GroupData data = YamlConfigProvider.getOrCreateConfig(groupsFile(), GroupData.class); - if (data == null || data.groups == null) - return; - - for (Map.Entry groupData : data.groups.entrySet()) + else { - GroupPermission group = getOrCreateGroup(groupData.getKey()); - group.setInnerMeta(groupData.getValue().meta); - - for (String pKey : groupData.getValue().permissions) - group.addPermission(permissionRepository.getPermission(pKey)); + saveGroups(); } } - + public void saveGroups() { - GroupData data = new GroupData(); + GroupsData data = new GroupsData(); - for (Map.Entry group : groups.entrySet()) - data.groups.put(group.getKey(), new World.HolderData(group.getValue())); + for (PermUser group : groups.values()) + data.groups.put(group.getName(), serializeContainer(group)); YamlConfigProvider.saveConfig(groupsFile(), data); } - - private World getOrCreateWorld(String name) + + public void saveUsers() { - World world = worlds.get(name); - if (world == null) - world = reloadWorld(name); + UsersData data = new UsersData(); - return world; + for (PermUser user : users.values()) + data.users.put(user.getName(), serializeContainer(user)); + + YamlConfigProvider.saveConfig(usersFile(), data); } - private User getUser(String worldName, String userName) + public void reloadUsers() { - World world = worlds.get(worldName); - if (world == null) - return null; + for(PermUser user : users.values()) + user.clearAll(); + users.clear(); - return world.get(userName); - } - - private User getOrCreateUser(String worldName, String userName) - { - World world = getOrCreateWorld(worldName); - - User user = world.get(userName); - if (user == null) + UsersData data = YamlConfigProvider.getOrCreateConfig(usersFile(), UsersData.class); + for(Map.Entry userData : data.users.entrySet()) { - user = new User(userName); - world.add(user); + PermUser container = new PermUser(userData.getKey()); + fillContainer(container, userData.getValue()); + users.put(userData.getKey().toLowerCase(), container); } + } + private void fillContainer(PermUser container, UserData data) + { + if(!StringUtils.isNullOrEmpty(data.inherits)) + container.setParent(permissionRepository.getContainer(data.inherits)); + + fillHolder(container.getGlobalHolder(), data.global); + for(Map.Entry worldData : data.worlds.entrySet()) + fillHolder(container.getOrCreateWorldHolder(worldData.getKey()), worldData.getValue()); + } + + private void fillHolder(PermissionHolder holder, HolderData data) + { + holder.setInnerMeta(data.meta); + for (String pKey : data.permissions) + holder.addPermission(permissionRepository.getPermission(pKey)); + } + + private UserData serializeContainer(PermUser group) + { + UserData user = new UserData(); + user.inherits = group.getParentName(); + user.global = new HolderData(group.getGlobalHolder()); + for(Map.Entry world : group.getInnerWorlds().entrySet()) + user.worlds.put(world.getKey(), new HolderData(world.getValue())); return user; } - public static String fixGroupKey(String key) + public static String fixMixinKey(String key) { - if (key.startsWith(GROUP_PREFIX)) + if (key.startsWith(MIXIN_PREFIX)) return key; else - return GROUP_PREFIX + key; + return MIXIN_PREFIX + key; } - private GroupPermission getOrCreateGroup(String name) + private MixinPermission getOrCreateMixin(String name) { - String groupKey = fixGroupKey(name); - GroupPermission group = groups.get(groupKey); - if (group == null) + String groupKey = fixMixinKey(name); + MixinPermission mixin = mixins.get(groupKey); + if (mixin == null) { - group = new GroupPermission(groupKey); - permissionRepository.registerPermission(group); - groups.put(groupKey, group); + mixin = new MixinPermission(groupKey); + permissionRepository.registerPermission(mixin); + mixins.put(groupKey, mixin); } - return group; + return mixin; } - private File worldFile(String name) + private PermUser getOrCreateGroup(String name) { - return new File(configDir, "users-" + name + ".yml"); + PermUser container = groups.get(name); + if(container == null) + { + container = new PermUser(name); + permissionRepository.registerContainer(name, container); + groups.put(name, container); + } + return container; + } + + private PermUser getOrCreateUser(String name) + { + PermUser container = users.get(name.toLowerCase()); + if(container == null) + { + container = new PermUser(name); + container.setParent(defaultGroup); + users.put(name, container); + } + return container; } private File groupsFile() @@ -276,8 +328,58 @@ return new File(configDir, GROUPS_CONFIG); } - public static class GroupData + private File usersFile() { - public Map groups = new HashMap(); + return new File(configDir, "users.yml"); + } + + private File mixinsFile() + { + return new File(configDir, MIXINS_CONFIG); + } + + public static class HolderData + { + public Map meta; + public List permissions; + + public HolderData() + { + meta = new HashMap(); + permissions = new ArrayList(); + } + + public HolderData(PermissionHolder holder) + { + meta = holder.getInnerMeta(); + permissions = holder.getInnerPermissions(); + } + + public boolean isEmpty() + { + return permissions.isEmpty() && meta.isEmpty(); + } + } + + public static class UserData + { + public String inherits = ""; + public HolderData global = new HolderData(); + public Map worlds = new LinkedHashMap(); + } + + public static class GroupsData + { + public Map groups = new LinkedHashMap(); + } + + public static class UsersData + { + public Map users = new LinkedHashMap(); + } + + public static class MixinData + { + public Map mixins = new LinkedHashMap(); } } diff --git a/src/main/java/org/ultramine/permission/internal/UserContainer.java b/src/main/java/org/ultramine/permission/internal/UserContainer.java deleted file mode 100644 index af8c40e..0000000 --- a/src/main/java/org/ultramine/permission/internal/UserContainer.java +++ /dev/null @@ -1,116 +0,0 @@ -package org.ultramine.permission.internal; - -import org.ultramine.permission.User; - -import java.util.HashMap; -import java.util.HashSet; -import java.util.Map; -import java.util.Set; - -public class UserContainer -{ - protected Map users; - protected UserContainer parentContainer; - - public UserContainer() - { - users = new HashMap(); - } - - public UserContainer(UserContainer parentContainer) - { - this(); - this.parentContainer = parentContainer; - } - - public final boolean checkUserPermission(String userName, String permissionKey) - { - return check(userName, permissionKey).asBoolean(); - } - - public String getUserMeta(String userName, String metaKey) - { - userName = userName.toLowerCase(); - String result = ""; - - User user = get(userName); - if (user != null) - result = user.getMeta(metaKey); - - if (result.isEmpty() && parentContainer != null) - result = parentContainer.getUserMeta(userName, metaKey); - - return result; - } - - protected CheckResult check(String userName, String permissionKey) - { - userName = userName.toLowerCase(); - CheckResult result = CheckResult.UNRESOLVED; - - User user = get(userName); - if (user != null) - result = user.check(permissionKey); - - if (result == CheckResult.UNRESOLVED && parentContainer != null) - result = parentContainer.check(userName, permissionKey); - - return result; - } - - public T get(String name) - { - return users.get(name.toLowerCase()); - } - - public Set getAllWithPermission(String permission) - { - Set result; - if (parentContainer != null) - result = parentContainer.getAllWithPermission(permission); - else - result = new HashSet(); - - for (String username : users.keySet()) - { - if (!result.contains(username) && checkUserPermission(username, permission)) - result.add(username); - } - - return result; - } - - public void add(T user) - { - if (users.containsKey(user.getName())) - return; - - users.put(user.getName(), user); - } - - public void remove(String name) - { - users.remove(name.toLowerCase()); - } - - public void remove(User user) - { - remove(user.getName()); - } - - public void clear() - { - users.clear(); - parentContainer = null; - } - - public boolean contains(String name) - { - return users.containsKey(name); - } - - public boolean contains(User user) - { - return contains(user.getName()); - } -} diff --git a/src/main/java/org/ultramine/server/PermissionHandler.java b/src/main/java/org/ultramine/server/PermissionHandler.java index 4f96ad2..e0dfe36 100644 --- a/src/main/java/org/ultramine/server/PermissionHandler.java +++ b/src/main/java/org/ultramine/server/PermissionHandler.java @@ -2,11 +2,11 @@ import net.minecraft.command.ICommandSender; import net.minecraft.server.MinecraftServer; -import org.ultramine.permission.GroupPermission; + +import org.ultramine.permission.MixinPermission; import org.ultramine.permission.IPermissionManager; import org.ultramine.permission.PermissionRepository; import org.ultramine.permission.internal.ServerPermissionManager; -import org.ultramine.permission.internal.UserContainer; public class PermissionHandler implements IPermissionManager { @@ -75,15 +75,15 @@ } @Override - public void addToWorld(String world, String permission) + public void addToMixin(String group, String permission) { - getHandler().addToWorld(world, permission); + getHandler().addToMixin(group, permission); } - + @Override - public void addToGroup(String group, String permission) + public void addToGroup(String group, String world, String permission) { - getHandler().addToGroup(group, permission); + getHandler().addToGroup(group, world, permission); } @Override @@ -98,15 +98,15 @@ } @Override - public void removeFromWorld(String world, String permission) + public void removeFromMixin(String group, String permission) { - getHandler().removeFromWorld(world, permission); + getHandler().removeFromMixin(group, permission); } - + @Override - public void removeFromGroup(String group, String permission) + public void removeFromGroup(String group, String world, String permission) { - getHandler().removeFromGroup(group, permission); + getHandler().removeFromGroup(group, world, permission); } @Override @@ -127,21 +127,33 @@ } @Override - public void setWorldMeta(String world, String key, String value) + public void setMixinMeta(String group, String key, String value) { - getHandler().setWorldMeta(world, key, value); + getHandler().setMixinMeta(group, key, value); } - + @Override - public void setGroupMeta(String group, String key, String value) + public void setGroupMeta(String group, String world, String key, String value) { - getHandler().setGroupMeta(group, key, value); + getHandler().setGroupMeta(group, world, key, value); } public void setMeta(ICommandSender player, String key, String value) { setMeta(worldName(player), player.getCommandSenderName(), key, value); } + + @Override + public void setUserGroup(String user, String group) + { + getHandler().setUserGroup(user, group); + } + + @Override + public void setGroupInherits(String group, String parent) + { + getHandler().setGroupInherits(group, parent); + } @Override public void save() @@ -161,15 +173,9 @@ return getHandler().getRepository(); } - @Override - public UserContainer getWorldContainer(String world) + public MixinPermission createGroup(String name, String... permissions) { - return getHandler().getWorldContainer(world); - } - - public GroupPermission createGroup(String name, String... permissions) - { - GroupPermission group = new GroupPermission(name); + MixinPermission group = new MixinPermission(name); for (String permission : permissions) group.addPermission(getRepository().getPermission(permission)); getRepository().registerPermission(group); diff --git a/src/main/java/org/ultramine/server/UltramineServerModContainer.java b/src/main/java/org/ultramine/server/UltramineServerModContainer.java index 151eede..a53495b 100644 --- a/src/main/java/org/ultramine/server/UltramineServerModContainer.java +++ b/src/main/java/org/ultramine/server/UltramineServerModContainer.java @@ -37,8 +37,8 @@ import org.ultramine.commands.basic.TechCommands; import org.ultramine.commands.basic.VanillaCommands; import org.ultramine.commands.syntax.DefaultCompleters; +import org.ultramine.permission.IPermissionManager; import org.ultramine.permission.commands.BasicPermissionCommands; -import org.ultramine.permission.internal.OpPermissionProxySet; import org.ultramine.server.chunk.ChunkProfiler; import org.ultramine.server.data.Databases; import org.ultramine.server.data.ServerDataLoader; @@ -124,8 +124,26 @@ e.registerCommands(VanillaCommands.class); e.registerCommands(BasicCommands.class); e.registerCommands(TechCommands.class); - - e.getPermissionHandler().createGroup(OpPermissionProxySet.OP_GROUP, "*"); + + for(String perm : new String[]{ + "command.help", + "command.vanilla.msg", + "command.vanilla.me", + "command.vanilla.kill", + "command.vanilla.list", + "ability.player.useblock", + "ability.player.useitem", + "ability.player.blockplace", + "ability.player.blockbreak", + "ability.player.attack", + }) + { + e.getPermissionHandler().addToGroup(IPermissionManager.DEFAULT_GROUP_NAME, IPermissionManager.GLOBAL_WORLD, perm); + } + e.getPermissionHandler().setGroupMeta(IPermissionManager.DEFAULT_GROUP_NAME, IPermissionManager.GLOBAL_WORLD, "color", "7"); + e.getPermissionHandler().addToGroup("admin", IPermissionManager.GLOBAL_WORLD, "*"); + e.getPermissionHandler().setGroupMeta("admin", IPermissionManager.GLOBAL_WORLD, "color", "c"); + e.getPermissionHandler().setGroupMeta("admin", IPermissionManager.GLOBAL_WORLD, "prefix", "&4[admin] "); if(e.getSide().isServer()) { @@ -137,6 +155,7 @@ @Subscribe public void serverStarted(FMLServerStartedEvent e) { + PermissionHandler.getInstance().reload(); ServerDataLoader loader = MinecraftServer.getServer().getConfigurationManager().getDataLoader(); CommandRegistry reg = ((CommandHandler)MinecraftServer.getServer().getCommandManager()).getRegistry(); loader.loadCache(); diff --git a/src/test/groovy/org/ultramine/permission/GroupPermissionTest.groovy b/src/test/groovy/org/ultramine/permission/GroupPermissionTest.groovy deleted file mode 100644 index 047e767..0000000 --- a/src/test/groovy/org/ultramine/permission/GroupPermissionTest.groovy +++ /dev/null @@ -1,84 +0,0 @@ -package org.ultramine.permission - -import spock.lang.Specification - -/** - * Created by Евгений on 08.05.2014. - */ -class GroupPermissionTest extends Specification { - - def "Test recursive calculation"() { - setup: "Prepare recursive groups" - def group1 = new GroupPermission("g1", [m1: "a"]) - def group2 = new GroupPermission("g2", [m2: "b"]) - group1.addPermission(group2) - group2.addPermission(group1) - - when: "Calculate permissions" - group1.calculate() - - then: "Both groups are not dirty" - !group1.isDirty() - !group2.isDirty() - - and: "Both groups have own meta" - group1.getMeta("m1") - group2.getMeta("m2") - } - - def "Test dirty notification"() { - setup: - def listener = Mock(IDirtyListener) - def group = new GroupPermission("group.test") - group.subscribe(listener) - - when: "Group becomes dirty several times" - group.makeDirty() - group.makeDirty() - group.makeDirty() - - then: "Listener is notified only once" - 1 * listener.makeDirty() - } - - def "Test subscribing to permission changes"() { - setup: - def permission = Mock(IPermission) { getKey() >> "c" } - def group = new GroupPermission("group.test") - - when: "Add permission to group" - group.addPermission(permission) - - then: "Group subscribes to permission" - 1 * permission.subscribe(group) - - when: "Remove permission from group" - group.removePermission(permission) - - then: "Group unsubscribes to permission" - 1 * permission.unsubscribe(group) - } - - def "Test meta parsing"() { - setup: - def group = new GroupPermission("group.test", [ - priority: "200", - perfix: "Test3" - ]) - - expect: - group.getKey() == "group.test" - group.getPriority() == 200 - group.getMeta("perfix") == "Test3" - group.getMeta("asd") == "" - } - - def "Test blank group"() { - setup: - def group = new GroupPermission("group.test", [:]) - - expect: - group.getKey() == "group.test" - group.getPriority() == 0 - } -} diff --git a/src/test/groovy/org/ultramine/permission/NegativePermissionTest.groovy b/src/test/groovy/org/ultramine/permission/NegativePermissionTest.groovy deleted file mode 100644 index ac0f759..0000000 --- a/src/test/groovy/org/ultramine/permission/NegativePermissionTest.groovy +++ /dev/null @@ -1,75 +0,0 @@ -package org.ultramine.permission - -import org.ultramine.permission.internal.MetaResolver -import org.ultramine.permission.internal.PermissionResolver - -import static org.ultramine.permission.internal.CheckResult.* -import spock.lang.Specification - -/** - * Created by Евгений on 08.05.2014. - */ -class NegativePermissionTest extends Specification { - - def "Test wrap IPermission"() { - setup: - IPermission permission = Mock(IPermission) { - getKey() >> "test.key" - getMeta("aza") >> "aza" - check("aza") >> TRUE - } - - when: "Create new NegativePermission" - def perm = new NegativePermission("^test.key", permission) - - then: "PermissionResolver was inverted" - perm.getKey() == "^test.key" - perm.getMeta("aza") == "" - perm.check("aza") == FALSE - } - - def "Test subscribe/unsubscribe permission"() { - setup: - IPermission permission = Mock(IPermission) - - def listener = Mock(IDirtyListener) - def perm = new NegativePermission("key", permission) - - when: "Try to subscribe/unsubscribe listener" - perm.subscribe(listener) - perm.unsubscribe(listener) - - then: "Permission received interactions" - 1 * permission.subscribe(listener) - 1 * permission.unsubscribe(listener) - 0 * listener._ - } - - def "Test blank meta"() { - - when: "Create new NegativePermission" - def perm = new NegativePermission("per", Mock(IPermission)) - - then: "Description is blank" - perm.getMeta("za") == "" - } - - def "Test integration with group permission"() { - setup: - def group = new GroupPermission("group") - group.addPermission(new DummyPermission("p1")) - - when: "Create negative permission" - def perm = new NegativePermission("key", group) - - then: "Negative permission contains group permissions" - perm.check("p1") == FALSE - - when: "Group permission updates" - group.addPermission(new DummyPermission("p2")) - - then: "Negative permission also updates" - perm.check("p1") == FALSE - perm.check("p2") == FALSE - } -} diff --git a/src/test/groovy/org/ultramine/permission/PermissionHolderTest.groovy b/src/test/groovy/org/ultramine/permission/PermissionHolderTest.groovy deleted file mode 100644 index 5e1f01b..0000000 --- a/src/test/groovy/org/ultramine/permission/PermissionHolderTest.groovy +++ /dev/null @@ -1,191 +0,0 @@ -package org.ultramine.permission - -import org.ultramine.permission.internal.MetaResolver -import org.ultramine.permission.internal.PermissionHolder -import org.ultramine.permission.internal.PermissionResolver -import spock.lang.Specification - -import static org.ultramine.permission.internal.CheckResult.FALSE -import static org.ultramine.permission.internal.CheckResult.TRUE -import static org.ultramine.permission.internal.CheckResult.UNRESOLVED - -class PermissionHolderTest extends Specification { - - MetaResolver createMetaResolver(Map meta) - { - def resolver = new MetaResolver() - resolver.merge(meta, 0) - return resolver - } - - def "Test calculation"() { - setup: - def spy = Spy(PermissionResolver) - def perm1 = Stub(IPermission) { - getKey() >> "p.1" - mergeMetaTo(_) >> { MetaResolver resolver -> - resolver.merge([test1: "1", test2: "1", test3: "1"], 1) - } - mergePermissionsTo(_) >> { PermissionResolver resolver -> - resolver.merge([test1: true, test2: true], 1) - } - } - def perm2 = Stub(IPermission) { - getKey() >> "p.2" - mergeMetaTo(_) >> { MetaResolver resolver -> - resolver.merge([test2: "2"], 2) - } - mergePermissionsTo(_) >> { PermissionResolver resolver -> - resolver.merge([test2: false], 2) - } - } - - def holder = new PermissionHolder([test1: "0"]) - holder.permissionResolver = spy - holder.addPermission(perm1) - holder.addPermission(perm2) - - when: "Calculate meta and permissions" - holder.calculate() - - then: "Permissions are calculated" - !holder.isDirty() - holder.check("test1") == TRUE - holder.check("test2") == FALSE - holder.check("test3") == UNRESOLVED - - and: "Meta is correct" - holder.getMeta("test1") == "0" - holder.getMeta("test2") == "2" - holder.getMeta("test3") == "1" - - when: "Calculate one more time" - holder.calculate() - - then: "Nothing happens" - !holder.isDirty() - 0 * spy._ - } - - def "Test clearPermissions"() { - setup: - def perm = Mock(IPermission) { - getKey() >> "p1" - mergeMetaTo(_) >> { MetaResolver resolver -> - resolver.merge([test2: "1"], 0) - } - mergePermissionsTo(_) >> { PermissionResolver resolver -> - resolver.merge([test2: true], 0) - } - } - def holder = new PermissionHolder([a: "1", b: "2"]) - holder.addPermission(new DummyPermission("p2")) - holder.addPermission(perm) - holder.calculate() - - when: "Clear holder's permissions" - holder.clearPermissions() - - then: "It contains only inner meta" - !holder.getMeta("test2") - holder.getMeta("a") == "1" - holder.getMeta("b") == "2" - - and: "It contains no permissions" - holder.check("test2") == UNRESOLVED - holder.check("p2") == UNRESOLVED - - and: "It unsubscribed from all permissions" - 1 * perm.unsubscribe(holder) - } - - def "Test clearMeta"() { - setup: - def perm = Mock(IPermission) { - getKey() >> "p1" - mergeMetaTo(_) >> { MetaResolver resolver -> - resolver.merge([test2: "1"], 0) - } - mergePermissionsTo(_) >> { PermissionResolver resolver -> - resolver.merge([test2: true], 0) - } - } - def holder = new PermissionHolder([a: "1", b: "2"]) - holder.addPermission(new DummyPermission("p2")) - holder.addPermission(perm) - - when: "Clear holder's meta" - holder.clearMeta() - - then: "It contains only permission's meta" - holder.getMeta("test2") == "1" - !holder.getMeta("a") - !holder.getMeta("b") - - and: "It contains all permissions" - holder.check("test2") != UNRESOLVED - holder.check("p2") != UNRESOLVED - - and: "It did not unsubscribe from all permissions" - 0 * perm.unsubscribe(holder) - } - - def "Test makeDirty"() { - setup: - def holder = new PermissionHolder() - holder.calculate() - - when: "makeDirty is called" - holder.makeDirty() - - then: "holder is dirty" - holder.isDirty() - } - - def "Test dirty methods"() { - setup: - def holder = Spy(PermissionHolder) - - when: "Call setMeta method" - holder.calculate() - holder.setMeta("test", "21") - - then: "Group becomes dirty" - 1 * holder.makeDirty() - - when: "Call removeMeta method" - holder.calculate() - holder.removeMeta("test") - - then: "Group becomes dirty" - 1 * holder.makeDirty() - - when: "Call addPermission method" - holder.calculate() - holder.addPermission(new DummyPermission("test")) - - then: "Group becomes dirty" - 1 * holder.makeDirty() - - when: "Call removePermission method" - holder.calculate() - holder.removePermission("test") - - then: "Group becomes dirty" - 1 * holder.makeDirty() - - when: "Call clearPermissions method" - holder.calculate() - holder.clearPermissions() - - then: "Group becomes dirty" - 1 * holder.makeDirty() - - when: "Call clearMeta method" - holder.calculate() - holder.clearMeta() - - then: "Group becomes dirty" - 1 * holder.makeDirty() - } -} diff --git a/src/test/groovy/org/ultramine/permission/PermissionRepositoryTest.groovy b/src/test/groovy/org/ultramine/permission/PermissionRepositoryTest.groovy deleted file mode 100644 index dfd67a9..0000000 --- a/src/test/groovy/org/ultramine/permission/PermissionRepositoryTest.groovy +++ /dev/null @@ -1,167 +0,0 @@ -package org.ultramine.permission - -import org.spockframework.mock.MockDetector -import spock.lang.Specification - -import static org.ultramine.permission.internal.CheckResult.FALSE -import static org.ultramine.permission.internal.CheckResult.TRUE -import static org.ultramine.permission.internal.CheckResult.UNRESOLVED - -class PermissionRepositoryTest extends Specification { - - def repository = new PermissionRepository() - - def "Test get proxy permission"() { - setup: - def detector = new MockDetector() - def perm = Mock(IPermission) { - getKey() >> "key" - getMeta(_) >> "test" - } - - when: "Try to get not registered permission" - def proxy = repository.getPermission("key") - - then: "Returned proxy of dummy permission" - proxy.getWrappedPermission().class == DummyPermission - proxy.isDummy(); - proxy.getMeta("") == "" - - when: "Register this permission" - repository.registerPermission(perm) - - then: "Proxy linked to added permission" - detector.isMock(proxy.getWrappedPermission()) - !proxy.isDummy() - proxy.getMeta("") == "test" - } - - def "Test registration of existed permission"() { - - when: "Register permission same key twice" - repository.registerPermission(Mock(IPermission) { getKey() >> "key"; getMeta(_) >> "1" }) - repository.registerPermission(Mock(IPermission) { getKey() >> "key"; getMeta(_) >> "2" }) - - then: "Exception is thrown" - thrown(IllegalArgumentException) - - and: "First permission is not overwritten" - repository.getPermission("key").getMeta("") == "1" - } - - def "Test proxy of IPermission"() { - setup: - def listener = Mock(IDirtyListener) - def perm = Mock(IPermission) { getKey() >> "key" } - - when: "Listener is subscribed to proxy permission" - def proxy = repository.getPermission("key") - proxy.subscribe(listener) - - and: "And IChangeablePermission is registered" - repository.registerPermission(perm) - - then: "Listener is notified" - 1 * listener.makeDirty() - - and: "Proxy is not Dummy" - !proxy.isDummy() - - and: "Listener is passed to permission" - 1 * perm.subscribe(listener) - - when: "Add another lister" - proxy.subscribe(Mock(IDirtyListener)) - - then: "Listener is added to permission" - 1 * perm.subscribe(_) - - when: "Remove listener" - proxy.unsubscribe(listener) - - then: "Listener is removed from permission" - 1 * perm.unsubscribe(listener) - } - - def "Test proxy unsubscribe"() { - setup: - def listener = Mock(IDirtyListener) - def perm = Mock(IPermission) { getKey() >> "key" } - - when: "Listener is subscribed and unsubscribe to proxy permission" - def proxy = repository.getPermission("key") - proxy.subscribe(listener) - proxy.unsubscribe(listener) - - and: "And permission is registered" - repository.registerPermission(perm) - - then: "0 listener passed to proxy" - 0 * perm.subscribe(_) - } - - def "Test negative key"() { - - when: "Try to get permission with negative key" - def perm = repository.getPermission("^group.admin") - - then: "Proxy of negative permission is return" - perm.class == NegativePermission - - and: "Negative permission linked to proxy" - perm.getWrappedPermission().getKey() == "group.admin" - perm.getWrappedPermission().class == PermissionRepository.ProxyPermission - } - - def "Test registre ^* permission"() { - - when: "Try to register ^* permission" - repository.registerPermission(Mock(IPermission) { getKey() >> "^test" }) - - then: "Exception is thrown" - thrown(IllegalArgumentException) - } - - def "Test integration"() { - setup: - def group1 = new GroupPermission("group1") - group1.addPermission(repository.getPermission("p1")) - group1.addPermission(repository.getPermission("group2")) - repository.registerPermission(group1) - - when: "Create negative permission" - def perm = repository.getPermission("^group1") - - then: "Negative permission contains group1 permissions" - perm.check("p1") == FALSE - perm.check("p2") == UNRESOLVED - perm.check("group2") == FALSE - perm.check("p3") == UNRESOLVED - - when: "Group permission updates" - group1.addPermission(repository.getPermission("p2")) - - then: "Negative permission also updates" - perm.check("p1") == FALSE - perm.check("p2") == FALSE - perm.check("group2") == FALSE - perm.check("p3") == UNRESOLVED - - when: "Register group2" - def group2 = new GroupPermission("group2") - group2.addPermission(repository.getPermission("^p3")) - repository.registerPermission(group2) - - then: "Negative permission also updates" - perm.check("p1") == FALSE - perm.check("p2") == FALSE - perm.check("group2") == FALSE - perm.check("p3") == TRUE - - and: "Group1 updates too" - group1.check("p1") == TRUE - group1.check("p2") == TRUE - group1.check("group2") == TRUE - group1.check("p3") == FALSE - } -} diff --git a/src/test/groovy/org/ultramine/permission/PermissionResolverTest.groovy b/src/test/groovy/org/ultramine/permission/PermissionResolverTest.groovy deleted file mode 100644 index 4665fda..0000000 --- a/src/test/groovy/org/ultramine/permission/PermissionResolverTest.groovy +++ /dev/null @@ -1,172 +0,0 @@ -package org.ultramine.permission - -import org.ultramine.permission.internal.PermissionResolver -import spock.lang.Specification -import spock.lang.Unroll -import static org.ultramine.permission.internal.CheckResult.* - -/** - * Created by Евгений on 08.05.2014. - */ -class PermissionResolverTest extends Specification { - - @Unroll - def "Test createForKey: #key"() { - when: "Creating resolver for key" - def resolver = PermissionResolver.createForKey(key, 0) - - then: "Resolver has this key" - resolver.check(key) == TRUE - - where: - key << ["test.key", "super.test.*", "^group.admin"] - } - - def "Test createInverted"() { - setup: - def resolver = new PermissionResolver() - resolver.merge("p.true", true, 0) - resolver.merge("p.false", false, 0) - - when: "Create inverted resolver" - def inverted = PermissionResolver.createInverted(resolver) - - then: "Permission are inverted" - inverted.check("p.false") == TRUE - inverted.check("p.true") == FALSE - - and: "New permissions are not created" - inverted.check("group.admin") == UNRESOLVED - } - - def "Test wildcard"() { - setup: "Resolver with wildcard permission" - def resolver = new PermissionResolver() - resolver.merge("test.perm.*", true, 0) - - expect: "Other permissions are not affected" - resolver.check("group.admin") == UNRESOLVED - resolver.check("group.admin.super") == UNRESOLVED - - and: "Parent nodes are not affected" - resolver.check("test") == UNRESOLVED - resolver.check("test.perm") == UNRESOLVED - - and: "Child nodes are affected" - resolver.check("test.perm.1") == TRUE - resolver.check("test.perm.2.3") == TRUE - } - - def "Test single permission override wildcard"() { - setup: "Resolver with wildcard and permission" - def resolver = new PermissionResolver() - resolver.merge("test.perm.*", true, 1) - resolver.merge("test.perm.super", false, 0) - - expect: "Wildcard has lower priority" - resolver.check("test.perm.super") == FALSE - resolver.check("test.perm.super2") == TRUE - - when: "Invert resolver" - resolver = PermissionResolver.createInverted(resolver) - - then: "Same effect" - resolver.check("test.perm.super") == TRUE - resolver.check("test.perm.super2") == FALSE - } - - def "Test higher node wildcard priority"() { - setup: "Resolver with wildcards" - def resolver = new PermissionResolver() - resolver.merge("test.perm.*", true, 1) - resolver.merge("test.perm.super.*", false, 0) - - expect: "Higher node wildcard has priority" - resolver.check("test.perm.super.p") == FALSE - resolver.check("test.perm.super.p.p") == FALSE - resolver.check("test.perm.p") == TRUE - - when: "Invert resolver" - resolver = PermissionResolver.createInverted(resolver) - - then: "Same effect" - resolver.check("test.perm.super.p") == TRUE - resolver.check("test.perm.super.p.p") == TRUE - resolver.check("test.perm.p") == FALSE - } - - def "Test clear"() { - setup: - def resolver = new PermissionResolver() - resolver.merge("test.perm", true, 0) - - when: "Clear resolver's data" - resolver.clear() - - then: "It has no permissions" - resolver.check("test.perm") == UNRESOLVED - } - - def "Test merge"() { - setup: "First resolver" - def resolver1 = new PermissionResolver() - resolver1.merge("test.perm", true, 1) - resolver1.merge("test.perm.1", true, 1) - resolver1.merge("test.perm.2", false, 1) - - and: "Second resolver" - def resolver2 = new PermissionResolver() - resolver2.merge("test.perm", false, 0) - resolver2.merge("test.perm.1", false, 2) - resolver2.merge("test.perm.3", true, 2) - - when: "Merging first then second" - def result = new PermissionResolver() - result.merge(resolver1, 1) - result.merge(resolver2, 2) - - then: - result.check("test.perm") == FALSE - result.check("test.perm.1") == FALSE - result.check("test.perm.2") == FALSE - result.check("test.perm.3") == TRUE - result.check("group.admin") == UNRESOLVED - - when: "Merge second then first" - result = new PermissionResolver() - result.merge(resolver2, 2) - result.merge(resolver1, 1) - - then: "Same effect" - result.check("test.perm") == FALSE - result.check("test.perm.1") == FALSE - result.check("test.perm.2") == FALSE - result.check("test.perm.3") == TRUE - result.check("group.admin") == UNRESOLVED - - when: "Merge first to second" - resolver2.merge(resolver1, 1) - - then: - resolver2.check("test.perm") == TRUE - resolver2.check("test.perm.1") == FALSE - resolver2.check("test.perm.2") == FALSE - resolver2.check("test.perm.3") == TRUE - resolver2.check("group.admin") == UNRESOLVED - } - - def "Test clear -> merge lower priority"() { - setup: "resolver(^test, 100)" - def resolver = new PermissionResolver() - resolver.merge("test", false, 100) - def inverted = new PermissionResolver() - inverted.merge("test", true, 50) - - when: - resolver.clear() - resolver.merge(inverted, 50) - - then: - resolver.check("test") == TRUE - } -} diff --git a/src/test/groovy/org/ultramine/permission/UserContainerTest.groovy b/src/test/groovy/org/ultramine/permission/UserContainerTest.groovy deleted file mode 100644 index a282b78..0000000 --- a/src/test/groovy/org/ultramine/permission/UserContainerTest.groovy +++ /dev/null @@ -1,57 +0,0 @@ -package org.ultramine.permission - -import org.ultramine.permission.internal.UserContainer -import spock.lang.Specification - -class UserContainerTest extends Specification { - - def stubUser(String name, Map permissions) { - def user = new User(name) - user.permissionResolver.merge(permissions, 0) - return user - } - - def "Test permissions"() { - setup: - def parent = new UserContainer() - def child = new UserContainer(parent) - - when: "Add user to parent container" - parent.add(stubUser("parent", [parent: true])) - - then: "Both container has user with permission" - parent.checkUserPermission("parent", "parent") - child.checkUserPermission("parent", "parent") - - when: "Add user to child container" - child.add(stubUser("child", [child: true])) - - then: "Only child container has user with permission" - !parent.checkUserPermission("child", "child") - child.checkUserPermission("child", "child") - - when: "Override parent user in child container" - child.add(stubUser("parent", [parent: false, child: true])) - - then: "Parent container permissions have lower priority" - !child.checkUserPermission("parent", "parent") - child.checkUserPermission("parent", "child") - - and: "Parent container permissions is not modified" - parent.checkUserPermission("parent", "parent") - !parent.checkUserPermission("parent", "child") - } - - def "Test second user cannot overwrite first"() { - setup: - def container = new UserContainer() - container.add(stubUser("u", [p1: true])) - - when: "Try to add user with same name" - container.add(stubUser("u", [p1:false, p2: true])) - - then: "User is not overwritten" - container.checkUserPermission("u", "p1") - !container.checkUserPermission("u", "p2") - } -} diff --git a/src/test/groovy/org/ultramine/permission/WorldTest.groovy b/src/test/groovy/org/ultramine/permission/WorldTest.groovy deleted file mode 100644 index 2afec70..0000000 --- a/src/test/groovy/org/ultramine/permission/WorldTest.groovy +++ /dev/null @@ -1,125 +0,0 @@ -package org.ultramine.permission - -import spock.lang.Specification - -class WorldTest extends Specification { - - def "Test config parsing"() { - setup: - def container = new World() - container.load(new PermissionRepository(), testWorldData) - - expect: "Permissions are loaded correctly" - container.checkUserPermission("user1", "d") - container.checkUserPermission("user1", "p.1") - !container.checkUserPermission("user1", "p.2") - !container.checkUserPermission("user1", "p.3") - !container.checkUserPermission("user1", "group.admin") - - !container.checkUserPermission("user2", "d") - !container.checkUserPermission("user2", "p.1") - !container.checkUserPermission("user2", "p.2") - container.checkUserPermission("user2", "p.3") - !container.checkUserPermission("user2", "group.admin") - - and: "Meta is loaded correctly" - container.get("user1").getMeta("a") == "a" - container.get("user1").getMeta("b") == "1" - - !container.get("user2").getMeta("a") - !container.get("user2").getMeta("b") - } - - def "Test config reloading"() { - setup: - def repository = new PermissionRepository() - def container = new World() - container.load(repository, testWorldData) - - when: "Add permission and meta to user" - container.get("user1").addPermission(repository.getPermission("test")) - container.get("user2").setMeta("test", "data") - - then: "User have this permission and meta" - container.checkUserPermission("user1", "test") - container.get("user2").getMeta("test") == "data" - - when: "Reloading container" - container.load(repository, testWorldData) - - then: "User have not this permission and meta" - !container.checkUserPermission("user1", "test") - !container.get("user2").getMeta("test") - - and: "Container is reloaded correctly" - container.checkUserPermission("user1", "d") - container.checkUserPermission("user1", "p.1") - !container.checkUserPermission("user1", "p.2") - !container.checkUserPermission("user1", "p.3") - !container.checkUserPermission("user1", "group.admin") - - !container.checkUserPermission("user2", "d") - !container.checkUserPermission("user2", "p.1") - !container.checkUserPermission("user2", "p.2") - container.checkUserPermission("user2", "p.3") - !container.checkUserPermission("user2", "group.admin") - - container.get("user1").getMeta("a") == "a" - container.get("user1").getMeta("b") == "1" - !container.get("user2").getMeta("a") - !container.get("user2").getMeta("b") - } - - def "Test config saving"() { - setup: - def repository = new PermissionRepository() - def container = new World() - def user = new User("test") - user.addPermission(repository.getPermission("p1")) - user.addPermission(repository.getPermission("^p2")) - - when: "Add data to container" - container.add(user) - container.getDefaultGroup().addPermission(repository.getPermission("d1")) - - and: "Save data" - def data = container.save() - - then: "Output data is correct" - data.default_group.permissions.contains('d1') - data.default_group.permissions.size() == 1 - data.users.size() == 1 - data.users['test'].permissions.containsAll(['p1', '^p2']) - data.users['test'].permissions.size() == 2 - data.users['test'].meta.size() == 0 - - when: "Try to load this config" - def anotherContainer = new World() - anotherContainer.load(repository, data) - - then: "Container loaded correctly" - anotherContainer.checkUserPermission("test", "d1") - anotherContainer.checkUserPermission("test", "p1") - !anotherContainer.checkUserPermission("test", "p2") - - anotherContainer.checkUserPermission("test1", "d1") - !anotherContainer.checkUserPermission("test1", "p1") - !anotherContainer.checkUserPermission("test1", "p2") - } - - - def testWorldData = new World.WorldData( - default_group: new World.HolderData( - permissions: ['d'] - ), - users: [ - user1: new World.HolderData( - permissions: ['p.1', '^p.2'], - meta: [a: 'a', b: "1"] - ), - user2: new World.HolderData( - permissions: ['^d', 'p.3'], - ) - ] - ) -}