1
0
mirror of https://e.coding.net/circlecloud/Residence.git synced 2025-11-26 22:06:07 +00:00

fix if Server Land is null can't load save file...

This commit is contained in:
j502647092
2015-06-02 22:11:20 +08:00
parent 7902c28967
commit 3e28dc9063

View File

@@ -1,18 +1,9 @@
/* /*
* To change this template, choose Tools | Templates * To change this template, choose Tools | Templates and open the template in the editor.
* and open the template in the editor.
*/ */
package com.bekvon.bukkit.residence.protection; package com.bekvon.bukkit.residence.protection;
import org.bukkit.ChatColor;
import com.bekvon.bukkit.residence.Residence;
import com.bekvon.bukkit.residence.event.ResidenceFlagChangeEvent;
import com.bekvon.bukkit.residence.event.ResidenceFlagCheckEvent;
import com.bekvon.bukkit.residence.event.ResidenceFlagEvent.FlagType;
import com.bekvon.bukkit.residence.event.ResidenceOwnerChangeEvent;
import com.bekvon.bukkit.residence.permissions.PermissionManager;
import com.bekvon.bukkit.residence.permissions.PermissionGroup;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collections; import java.util.Collections;
import java.util.HashMap; import java.util.HashMap;
@@ -20,484 +11,487 @@ import java.util.Iterator;
import java.util.Map; import java.util.Map;
import java.util.Map.Entry; import java.util.Map.Entry;
import java.util.Set; import java.util.Set;
import org.bukkit.ChatColor;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import com.bekvon.bukkit.residence.Residence;
import com.bekvon.bukkit.residence.event.ResidenceFlagChangeEvent;
import com.bekvon.bukkit.residence.event.ResidenceFlagCheckEvent;
import com.bekvon.bukkit.residence.event.ResidenceFlagEvent.FlagType;
import com.bekvon.bukkit.residence.event.ResidenceOwnerChangeEvent;
import com.bekvon.bukkit.residence.permissions.PermissionGroup;
import com.bekvon.bukkit.residence.permissions.PermissionManager;
/** /**
* *
* @author Administrator * @author Administrator
*/ */
public class ResidencePermissions extends FlagPermissions { public class ResidencePermissions extends FlagPermissions {
protected String owner; public static ResidencePermissions load(ClaimedResidence res, Map<String, Object> root) throws Exception {
protected String world; ResidencePermissions newperms = new ResidencePermissions(res);
protected ClaimedResidence residence; newperms.owner = (String) root.get("Owner");
if (newperms.owner == null) {
newperms.owner = (String) root.get("OwnerLastKnownName");
}
if (newperms.owner == null) {
Residence.getLog().warning("发现未知所有者的领地,转换为Server Land...");
newperms.owner = "Server Land";
}
newperms.world = (String) root.get("World");
FlagPermissions.load(root, newperms);
if (newperms.owner == null)
throw new Exception("错误的Owner数据...");
if (newperms.world == null)
throw new Exception("错误的World数据...");
if (newperms.playerFlags == null)
throw new Exception("错误的PlayerFlags数据...");
if (newperms.groupFlags == null)
throw new Exception("错误的GroupFlags数据...");
if (newperms.cuboidFlags == null)
throw new Exception("错误的CuboidFlags数据...");
newperms.fixNames();
return newperms;
}
private ResidencePermissions(ClaimedResidence res) protected String owner;
{ protected String world;
residence = res;
}
public ResidencePermissions(ClaimedResidence res, String creator, String inworld) protected ClaimedResidence residence;
{
this(res);
owner = creator;
world = inworld;
}
public boolean playerHas(String player, String flag, boolean def) private ResidencePermissions(ClaimedResidence res) {
{ residence = res;
return this.playerHas(player, world, flag, def); }
}
@Override public ResidencePermissions(ClaimedResidence res, String creator, String inworld) {
public boolean playerHas(String player, String world, String flag, boolean def) { this(res);
ResidenceFlagCheckEvent fc = new ResidenceFlagCheckEvent(residence,flag,FlagType.PLAYER,player,def); owner = creator;
Residence.getServ().getPluginManager().callEvent(fc); world = inworld;
if(fc.isOverriden()) }
return fc.getOverrideValue();
return super.playerHas(player, world, flag, def);
}
@Override public void applyDefaultFlags() {
public boolean groupHas(String group, String flag, boolean def) { PermissionManager gm = Residence.getPermissionManager();
ResidenceFlagCheckEvent fc = new ResidenceFlagCheckEvent(residence,flag,FlagType.GROUP,group,def); PermissionGroup group = gm.getGroup(owner, world);
Residence.getServ().getPluginManager().callEvent(fc); Set<Entry<String, Boolean>> dflags = group.getDefaultResidenceFlags();
if(fc.isOverriden()) Set<Entry<String, Boolean>> dcflags = group.getDefaultCreatorFlags();
return fc.getOverrideValue(); Set<Entry<String, Map<String, Boolean>>> dgflags = group.getDefaultGroupFlags();
return super.groupHas(group, flag, def); this.applyGlobalDefaults();
} for (Entry<String, Boolean> next : dflags) {
if (this.checkValidFlag(next.getKey(), true)) {
if (next.getValue()) {
this.setFlag(next.getKey(), FlagState.TRUE);
} else {
this.setFlag(next.getKey(), FlagState.FALSE);
}
}
}
for (Entry<String, Boolean> next : dcflags) {
if (this.checkValidFlag(next.getKey(), false)) {
if (next.getValue()) {
this.setPlayerFlag(owner, next.getKey(), FlagState.TRUE);
} else {
this.setPlayerFlag(owner, next.getKey(), FlagState.FALSE);
}
}
}
for (Entry<String, Map<String, Boolean>> entry : dgflags) {
Map<String, Boolean> value = entry.getValue();
for (Entry<String, Boolean> flag : value.entrySet()) {
if (flag.getValue()) {
this.setGroupFlag(entry.getKey(), flag.getKey(), FlagState.TRUE);
} else {
this.setGroupFlag(entry.getKey(), flag.getKey(), FlagState.FALSE);
}
}
}
}
@Override public void applyDefaultFlags(Player player, boolean resadmin) {
public boolean has(String flag, boolean def) { if (this.hasResidencePermission(player, true) || resadmin) {
ResidenceFlagCheckEvent fc = new ResidenceFlagCheckEvent(residence,flag,FlagType.RESIDENCE,null,def); this.applyDefaultFlags();
Residence.getServ().getPluginManager().callEvent(fc); player.sendMessage(ChatColor.YELLOW + Residence.getLanguage().getPhrase("FlagsDefault"));
if(fc.isOverriden()) } else {
return fc.getOverrideValue(); player.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("NoPermission"));
return super.has(flag, def); }
} }
public void applyGlobalDefaults() {
this.clearFlags();
FlagPermissions gRD = Residence.getConfigManager().getGlobalResidenceDefaultFlags();
FlagPermissions gCD = Residence.getConfigManager().getGlobalCreatorDefaultFlags();
Map<String, FlagPermissions> gGD = Residence.getConfigManager()
.getGlobalGroupDefaultFlags();
for (Entry<String, Boolean> entry : gRD.cuboidFlags.entrySet()) {
if (entry.getValue()) {
this.setFlag(entry.getKey(), FlagState.TRUE);
} else {
this.setFlag(entry.getKey(), FlagState.FALSE);
}
}
for (Entry<String, Boolean> entry : gCD.cuboidFlags.entrySet()) {
if (entry.getValue()) {
this.setPlayerFlag(owner, entry.getKey(), FlagState.TRUE);
} else {
this.setPlayerFlag(owner, entry.getKey(), FlagState.FALSE);
}
}
for (Entry<String, FlagPermissions> entry : gGD.entrySet()) {
for (Entry<String, Boolean> flag : entry.getValue().cuboidFlags.entrySet()) {
if (flag.getValue()) {
this.setGroupFlag(entry.getKey(), flag.getKey(), FlagState.TRUE);
} else {
this.setGroupFlag(entry.getKey(), flag.getKey(), FlagState.FALSE);
}
}
}
}
public boolean hasApplicableFlag(String player, String flag) public void applyTemplate(Player player, FlagPermissions list, boolean resadmin) {
{ if (player != null) {
return super.inheritanceIsPlayerSet(player,flag) || super.inheritanceIsGroupSet(Residence.getPermissionManager().getGroupNameByPlayer(player,world),flag) || super.inheritanceIsSet(flag); if (!player.getName().equals(owner) && !resadmin) {
} player.sendMessage(ChatColor.RED
+ Residence.getLanguage().getPhrase("NoPermission"));
return;
}
} else {
resadmin = true;
}
PermissionGroup group = Residence.getPermissionManager().getGroup(owner, world);
for (Entry<String, Boolean> flag : list.cuboidFlags.entrySet()) {
if (group.hasFlagAccess(flag.getKey()) || resadmin) {
this.cuboidFlags.put(flag.getKey(), flag.getValue());
} else {
player.sendMessage(ChatColor.RED
+ Residence.getLanguage().getPhrase("FlagSetDeny",
ChatColor.YELLOW + flag.getKey() + ChatColor.RED));
}
}
for (Entry<String, Map<String, Boolean>> plists : list.playerFlags.entrySet()) {
for (Entry<String, Boolean> flag : plists.getValue().entrySet()) {
if (group.hasFlagAccess(flag.getKey()) || resadmin) {
if (!this.playerFlags.containsKey(plists.getKey())) {
this.playerFlags.put(plists.getKey(),
Collections.synchronizedMap(new HashMap<String, Boolean>()));
}
this.playerFlags.get(plists.getKey()).put(flag.getKey(), flag.getValue());
} else {
player.sendMessage(ChatColor.RED
+ Residence.getLanguage().getPhrase("FlagSetDeny",
ChatColor.YELLOW + flag.getKey() + ChatColor.RED));
}
}
}
for (Entry<String, Map<String, Boolean>> glists : list.groupFlags.entrySet()) {
for (Entry<String, Boolean> flag : glists.getValue().entrySet()) {
if (group.hasFlagAccess(flag.getKey()) || resadmin) {
if (!this.groupFlags.containsKey(glists.getKey())) {
this.groupFlags.put(glists.getKey(),
Collections.synchronizedMap(new HashMap<String, Boolean>()));
}
this.groupFlags.get(glists.getKey()).put(flag.getKey(), flag.getValue());
} else {
player.sendMessage(ChatColor.RED
+ Residence.getLanguage().getPhrase("FlagSetDeny",
ChatColor.YELLOW + flag.getKey() + ChatColor.RED));
}
}
}
if (player != null) {
player.sendMessage(ChatColor.GREEN
+ Residence.getLanguage().getPhrase("PermissionsApply"));
}
}
public void applyTemplate(Player player, FlagPermissions list, boolean resadmin) private boolean checkCanSetFlag(Player player, String flag, FlagState state, boolean globalflag, boolean resadmin) {
{ if (!checkValidFlag(flag, globalflag)) {
if(player!=null) player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("InvalidFlag"));
{ return false;
if(!player.getName().equals(owner) && !resadmin) }
{ if (state == FlagState.INVALID) {
player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("NoPermission")); player.sendMessage(ChatColor.RED
return; + Residence.getLanguage().getPhrase("InvalidFlagState"));
} return false;
} }
else if (!resadmin) {
{ if (!this.hasResidencePermission(player, false)) {
resadmin = true; player.sendMessage(ChatColor.RED
} + Residence.getLanguage().getPhrase("NoPermission"));
PermissionGroup group = Residence.getPermissionManager().getGroup(owner,world); return false;
for(Entry<String, Boolean> flag : list.cuboidFlags.entrySet()) }
{ if (!hasFlagAccess(owner, flag)) {
if(group.hasFlagAccess(flag.getKey()) || resadmin) player.sendMessage(ChatColor.RED
{ + Residence.getLanguage().getPhrase("OwnerNoPermission"));
this.cuboidFlags.put(flag.getKey(), flag.getValue()); return false;
} }
else }
{ return true;
player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("FlagSetDeny", ChatColor.YELLOW+flag.getKey() + ChatColor.RED)); }
}
}
for(Entry<String, Map<String, Boolean>> plists : list.playerFlags.entrySet())
{
for(Entry<String, Boolean> flag : plists.getValue().entrySet())
{
if(group.hasFlagAccess(flag.getKey()) || resadmin)
{
if(!this.playerFlags.containsKey(plists.getKey()))
this.playerFlags.put(plists.getKey(), Collections.synchronizedMap(new HashMap<String,Boolean>()));
this.playerFlags.get(plists.getKey()).put(flag.getKey(), flag.getValue());
}
else
{
player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("FlagSetDeny", ChatColor.YELLOW+flag.getKey() + ChatColor.RED));
}
}
}
for(Entry<String, Map<String, Boolean>> glists : list.groupFlags.entrySet())
{
for(Entry<String, Boolean> flag : glists.getValue().entrySet())
{
if(group.hasFlagAccess(flag.getKey()) || resadmin)
{
if(!this.groupFlags.containsKey(glists.getKey()))
this.groupFlags.put(glists.getKey(), Collections.synchronizedMap(new HashMap<String,Boolean>()));
this.groupFlags.get(glists.getKey()).put(flag.getKey(), flag.getValue());
}
else
{
player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("FlagSetDeny", ChatColor.YELLOW+flag.getKey() + ChatColor.RED));
}
}
}
if(player!=null)
player.sendMessage(ChatColor.GREEN+Residence.getLanguage().getPhrase("PermissionsApply"));
}
public boolean hasResidencePermission(Player player, boolean requireOwner) { public void fixNames() {
if (Residence.getConfigManager().enabledRentSystem()) { ArrayList<String> fixNames = new ArrayList<String>();
String resname = residence.getName(); Iterator<Entry<String, Map<String, Boolean>>> it = playerFlags.entrySet().iterator();
if (Residence.getRentManager().isRented(resname)) { while (it.hasNext()) {
if (requireOwner) { String name = it.next().getKey();
return false; if (!name.equals(name.toLowerCase())) {
} fixNames.add(name);
String renter = Residence.getRentManager().getRentingPlayer(resname); }
if (player.getName().equalsIgnoreCase(renter)) { }
return true; for (String name : fixNames) {
} else { Map<String, Boolean> get = playerFlags.get(name);
return (playerHas(player.getName(), "admin", false)); playerFlags.remove(name);
} playerFlags.put(name.toLowerCase(), get);
} }
} }
if (requireOwner) {
return (owner.equalsIgnoreCase(player.getName()));
}
return (playerHas(player.getName(), "admin", false) || owner.equalsIgnoreCase(player.getName()));
}
private boolean checkCanSetFlag(Player player, String flag, FlagState state, boolean globalflag, boolean resadmin) public String getOwner() {
{ return owner;
if(!checkValidFlag(flag,globalflag)) }
{
player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("InvalidFlag"));
return false;
}
if(state == FlagState.INVALID)
{
player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("InvalidFlagState"));
return false;
}
if(!resadmin)
{
if(!this.hasResidencePermission(player,false))
{
player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("NoPermission"));
return false;
}
if(!hasFlagAccess(owner, flag))
{
player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("OwnerNoPermission"));
return false;
}
}
return true;
}
private boolean hasFlagAccess(String player, String flag) public String getWorld() {
{ return world;
PermissionGroup group = Residence.getPermissionManager().getGroup(player,world); }
return group.hasFlagAccess(flag);
}
public boolean setPlayerFlag(Player player, String targetPlayer, String flag, String flagstate, boolean resadmin) { @Override
if(validFlagGroups.containsKey(flag)) public boolean groupHas(String group, String flag, boolean def) {
return this.setFlagGroupOnPlayer(player, targetPlayer, flag, flagstate, resadmin); ResidenceFlagCheckEvent fc = new ResidenceFlagCheckEvent(residence, flag, FlagType.GROUP,
FlagState state = FlagPermissions.stringToFlagState(flagstate); group, def);
if (checkCanSetFlag(player, flag, state, false, resadmin)) { Residence.getServ().getPluginManager().callEvent(fc);
ResidenceFlagChangeEvent fc = new ResidenceFlagChangeEvent(residence, player, flag, ResidenceFlagChangeEvent.FlagType.PLAYER, state, targetPlayer); if (fc.isOverriden())
Residence.getServ().getPluginManager().callEvent(fc); return fc.getOverrideValue();
if (fc.isCancelled()) return super.groupHas(group, flag, def);
return false; }
if(super.setPlayerFlag(targetPlayer, flag, state))
{
player.sendMessage(ChatColor.GREEN+Residence.getLanguage().getPhrase("FlagSet"));
return true;
}
}
return false;
}
public boolean setGroupFlag(Player player, String group, String flag, String flagstate, boolean resadmin) { @Override
group = group.toLowerCase(); public boolean has(String flag, boolean def) {
if(validFlagGroups.containsKey(flag)) ResidenceFlagCheckEvent fc = new ResidenceFlagCheckEvent(residence, flag,
return this.setFlagGroupOnGroup(player, flag, group, flagstate, resadmin); FlagType.RESIDENCE, null, def);
FlagState state = FlagPermissions.stringToFlagState(flagstate); Residence.getServ().getPluginManager().callEvent(fc);
if (checkCanSetFlag(player, flag, state, false, resadmin)) { if (fc.isOverriden())
if (Residence.getPermissionManager().hasGroup(group)) { return fc.getOverrideValue();
ResidenceFlagChangeEvent fc = new ResidenceFlagChangeEvent(residence, player, flag, ResidenceFlagChangeEvent.FlagType.GROUP, state, group); return super.has(flag, def);
Residence.getServ().getPluginManager().callEvent(fc); }
if (fc.isCancelled())
return false;
if(super.setGroupFlag(group, flag, state))
{
player.sendMessage(ChatColor.GREEN+Residence.getLanguage().getPhrase("FlagSet"));
return true;
}
} else {
player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("InvalidGroup"));
return false;
}
}
return false;
}
public boolean setFlag(Player player, String flag, String flagstate, boolean resadmin) { public boolean hasApplicableFlag(String player, String flag) {
if(validFlagGroups.containsKey(flag)) return super.inheritanceIsPlayerSet(player, flag)
return this.setFlagGroup(player, flag, flagstate, resadmin); || super.inheritanceIsGroupSet(Residence.getPermissionManager()
FlagState state = FlagPermissions.stringToFlagState(flagstate); .getGroupNameByPlayer(player, world), flag) || super.inheritanceIsSet(flag);
if (checkCanSetFlag(player, flag, state, true, resadmin)) { }
ResidenceFlagChangeEvent fc = new ResidenceFlagChangeEvent(residence,player,flag,ResidenceFlagChangeEvent.FlagType.RESIDENCE,state,null);
Residence.getServ().getPluginManager().callEvent(fc);
if(fc.isCancelled())
return false;
if(super.setFlag(flag, state))
{
player.sendMessage(ChatColor.GREEN+Residence.getLanguage().getPhrase("FlagSet"));
return true;
}
}
return false;
}
public boolean removeAllPlayerFlags(Player player, String targetPlayer, boolean resadmin) { private boolean hasFlagAccess(String player, String flag) {
if (this.hasResidencePermission(player, false) || resadmin) { PermissionGroup group = Residence.getPermissionManager().getGroup(player, world);
ResidenceFlagChangeEvent fc = new ResidenceFlagChangeEvent(residence, player, "ALL", ResidenceFlagChangeEvent.FlagType.RESIDENCE, FlagState.NEITHER, null); return group.hasFlagAccess(flag);
Residence.getServ().getPluginManager().callEvent(fc); }
if (fc.isCancelled()) {
return false;
}
super.removeAllPlayerFlags(targetPlayer);
player.sendMessage(ChatColor.GREEN+Residence.getLanguage().getPhrase("FlagSet"));
return true;
}
return false;
}
public boolean removeAllGroupFlags(Player player, String group, boolean resadmin) { public boolean hasResidencePermission(Player player, boolean requireOwner) {
if (this.hasResidencePermission(player, false) || resadmin) { if (Residence.getConfigManager().enabledRentSystem()) {
ResidenceFlagChangeEvent fc = new ResidenceFlagChangeEvent(residence, player, "ALL", ResidenceFlagChangeEvent.FlagType.GROUP, FlagState.NEITHER, null); String resname = residence.getName();
Residence.getServ().getPluginManager().callEvent(fc); if (Residence.getRentManager().isRented(resname)) {
if (fc.isCancelled()) { if (requireOwner)
return false; return false;
} String renter = Residence.getRentManager().getRentingPlayer(resname);
super.removeAllGroupFlags(group); if (player.getName().equalsIgnoreCase(renter))
player.sendMessage(ChatColor.GREEN+Residence.getLanguage().getPhrase("FlagSet")); return true;
return true; else
} return (playerHas(player.getName(), "admin", false));
return false; }
} }
if (requireOwner)
return (owner.equalsIgnoreCase(player.getName()));
return (playerHas(player.getName(), "admin", false) || owner.equalsIgnoreCase(player
.getName()));
}
public boolean playerHas(String player, String flag, boolean def) {
return this.playerHas(player, world, flag, def);
}
@Override @Override
public boolean setFlag(String flag, FlagState state) { public boolean playerHas(String player, String world, String flag, boolean def) {
ResidenceFlagChangeEvent fc = new ResidenceFlagChangeEvent(residence, null,flag,ResidenceFlagChangeEvent.FlagType.RESIDENCE,state,null); ResidenceFlagCheckEvent fc = new ResidenceFlagCheckEvent(residence, flag, FlagType.PLAYER,
Residence.getServ().getPluginManager().callEvent(fc); player, def);
if(fc.isCancelled()) Residence.getServ().getPluginManager().callEvent(fc);
return false; if (fc.isOverriden())
return super.setFlag(flag, state); return fc.getOverrideValue();
} return super.playerHas(player, world, flag, def);
}
@Override public boolean removeAllGroupFlags(Player player, String group, boolean resadmin) {
public boolean setGroupFlag(String group, String flag, FlagState state) { if (this.hasResidencePermission(player, false) || resadmin) {
ResidenceFlagChangeEvent fc = new ResidenceFlagChangeEvent(residence, null,flag,ResidenceFlagChangeEvent.FlagType.GROUP,state,group); ResidenceFlagChangeEvent fc = new ResidenceFlagChangeEvent(residence, player, "ALL",
Residence.getServ().getPluginManager().callEvent(fc); ResidenceFlagChangeEvent.FlagType.GROUP, FlagState.NEITHER, null);
if(fc.isCancelled()) Residence.getServ().getPluginManager().callEvent(fc);
return false; if (fc.isCancelled())
return super.setGroupFlag(group, flag, state); return false;
} super.removeAllGroupFlags(group);
player.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("FlagSet"));
return true;
}
return false;
}
@Override public boolean removeAllPlayerFlags(Player player, String targetPlayer, boolean resadmin) {
public boolean setPlayerFlag(String player, String flag, FlagState state) { if (this.hasResidencePermission(player, false) || resadmin) {
ResidenceFlagChangeEvent fc = new ResidenceFlagChangeEvent(residence, null,flag,ResidenceFlagChangeEvent.FlagType.PLAYER,state, player); ResidenceFlagChangeEvent fc = new ResidenceFlagChangeEvent(residence, player, "ALL",
Residence.getServ().getPluginManager().callEvent(fc); ResidenceFlagChangeEvent.FlagType.RESIDENCE, FlagState.NEITHER, null);
if(fc.isCancelled()) Residence.getServ().getPluginManager().callEvent(fc);
return false; if (fc.isCancelled())
return super.setPlayerFlag(player,flag,state); return false;
} super.removeAllPlayerFlags(targetPlayer);
player.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("FlagSet"));
return true;
}
return false;
}
public void applyDefaultFlags(Player player, boolean resadmin) @Override
{ public Map<String, Object> save() {
if(this.hasResidencePermission(player, true) || resadmin) Map<String, Object> root = super.save();
{ root.put("Owner", owner);
this.applyDefaultFlags(); root.put("World", world);
player.sendMessage(ChatColor.YELLOW+Residence.getLanguage().getPhrase("FlagsDefault")); return root;
} }
else
player.sendMessage(ChatColor.GREEN+Residence.getLanguage().getPhrase("NoPermission"));
}
public void applyDefaultFlags() public boolean setFlag(Player player, String flag, String flagstate, boolean resadmin) {
{ if (validFlagGroups.containsKey(flag))
PermissionManager gm = Residence.getPermissionManager(); return this.setFlagGroup(player, flag, flagstate, resadmin);
PermissionGroup group = gm.getGroup(owner, world); FlagState state = FlagPermissions.stringToFlagState(flagstate);
Set<Entry<String, Boolean>> dflags = group.getDefaultResidenceFlags(); if (checkCanSetFlag(player, flag, state, true, resadmin)) {
Set<Entry<String, Boolean>> dcflags = group.getDefaultCreatorFlags(); ResidenceFlagChangeEvent fc = new ResidenceFlagChangeEvent(residence, player, flag,
Set<Entry<String, Map<String, Boolean>>> dgflags = group.getDefaultGroupFlags(); ResidenceFlagChangeEvent.FlagType.RESIDENCE, state, null);
this.applyGlobalDefaults(); Residence.getServ().getPluginManager().callEvent(fc);
for (Entry<String, Boolean> next : dflags) { if (fc.isCancelled())
if (this.checkValidFlag(next.getKey(), true)) { return false;
if (next.getValue()) { if (super.setFlag(flag, state)) {
this.setFlag(next.getKey(), FlagState.TRUE); player.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("FlagSet"));
} else { return true;
this.setFlag(next.getKey(), FlagState.FALSE); }
} }
} return false;
} }
for (Entry<String, Boolean> next : dcflags) {
if (this.checkValidFlag(next.getKey(), false)) {
if (next.getValue()) {
this.setPlayerFlag(owner, next.getKey(), FlagState.TRUE);
} else {
this.setPlayerFlag(owner, next.getKey(), FlagState.FALSE);
}
}
}
for (Entry<String, Map<String, Boolean>> entry : dgflags)
{
Map<String, Boolean> value = entry.getValue();
for(Entry<String, Boolean> flag : value.entrySet())
{
if(flag.getValue())
{
this.setGroupFlag(entry.getKey(), flag.getKey(), FlagState.TRUE);
}
else
{
this.setGroupFlag(entry.getKey(), flag.getKey(), FlagState.FALSE);
}
}
}
}
public void setOwner(String newOwner, boolean resetFlags) @Override
{ public boolean setFlag(String flag, FlagState state) {
ResidenceOwnerChangeEvent ownerchange = new ResidenceOwnerChangeEvent(residence,newOwner); ResidenceFlagChangeEvent fc = new ResidenceFlagChangeEvent(residence, null, flag,
Residence.getServ().getPluginManager().callEvent(ownerchange); ResidenceFlagChangeEvent.FlagType.RESIDENCE, state, null);
owner = newOwner; Residence.getServ().getPluginManager().callEvent(fc);
if(resetFlags) if (fc.isCancelled())
this.applyDefaultFlags(); return false;
} return super.setFlag(flag, state);
}
public String getOwner() public boolean setFlagGroup(Player player, String flaggroup, String state, boolean resadmin) {
{ if (ResidencePermissions.validFlagGroups.containsKey(flaggroup)) {
return owner; ArrayList<String> flags = ResidencePermissions.validFlagGroups.get(flaggroup);
} boolean changed = false;
for (String flag : flags) {
if (this.setFlag(player, flag, state, resadmin)) {
changed = true;
}
}
return changed;
}
return false;
}
public String getWorld() public boolean setFlagGroupOnGroup(Player player, String flaggroup, String group, String state, boolean resadmin) {
{ if (ResidencePermissions.validFlagGroups.containsKey(flaggroup)) {
return world; ArrayList<String> flags = ResidencePermissions.validFlagGroups.get(flaggroup);
} boolean changed = false;
for (String flag : flags) {
if (this.setGroupFlag(player, group, flag, state, resadmin)) {
changed = true;
}
}
return changed;
}
return false;
}
@Override public boolean setFlagGroupOnPlayer(Player player, String target, String flaggroup, String state, boolean resadmin) {
public Map<String, Object> save() { if (ResidencePermissions.validFlagGroups.containsKey(flaggroup)) {
Map<String, Object> root = super.save(); ArrayList<String> flags = ResidencePermissions.validFlagGroups.get(flaggroup);
root.put("Owner", owner); boolean changed = false;
root.put("World", world); for (String flag : flags) {
return root; if (this.setPlayerFlag(player, target, flag, state, resadmin)) {
} changed = true;
}
}
return changed;
}
return false;
}
public static ResidencePermissions load(ClaimedResidence res, Map<String, Object> root) throws Exception { public boolean setGroupFlag(Player player, String group, String flag, String flagstate, boolean resadmin) {
ResidencePermissions newperms = new ResidencePermissions(res); group = group.toLowerCase();
newperms.owner = (String) root.get("Owner"); if (validFlagGroups.containsKey(flag))
newperms.world = (String) root.get("World"); return this.setFlagGroupOnGroup(player, flag, group, flagstate, resadmin);
FlagPermissions.load(root, newperms); FlagState state = FlagPermissions.stringToFlagState(flagstate);
if(newperms.owner==null||newperms.world==null||newperms.playerFlags==null||newperms.groupFlags==null||newperms.cuboidFlags==null) if (checkCanSetFlag(player, flag, state, false, resadmin)) {
throw new Exception("Invalid Residence Permissions..."); if (Residence.getPermissionManager().hasGroup(group)) {
newperms.fixNames(); ResidenceFlagChangeEvent fc = new ResidenceFlagChangeEvent(residence, player, flag,
return newperms; ResidenceFlagChangeEvent.FlagType.GROUP, state, group);
} Residence.getServ().getPluginManager().callEvent(fc);
if (fc.isCancelled())
return false;
if (super.setGroupFlag(group, flag, state)) {
player.sendMessage(ChatColor.GREEN
+ Residence.getLanguage().getPhrase("FlagSet"));
return true;
}
} else {
player.sendMessage(ChatColor.RED
+ Residence.getLanguage().getPhrase("InvalidGroup"));
return false;
}
}
return false;
}
public void fixNames() @Override
{ public boolean setGroupFlag(String group, String flag, FlagState state) {
ArrayList<String> fixNames = new ArrayList<String>(); ResidenceFlagChangeEvent fc = new ResidenceFlagChangeEvent(residence, null, flag,
Iterator<Entry<String, Map<String, Boolean>>> it = playerFlags.entrySet().iterator(); ResidenceFlagChangeEvent.FlagType.GROUP, state, group);
while(it.hasNext()) Residence.getServ().getPluginManager().callEvent(fc);
{ if (fc.isCancelled())
String name = it.next().getKey(); return false;
if(!name.equals(name.toLowerCase())) return super.setGroupFlag(group, flag, state);
{ }
fixNames.add(name);
}
}
for(String name : fixNames)
{
Map<String, Boolean> get = playerFlags.get(name);
playerFlags.remove(name);
playerFlags.put(name.toLowerCase(), get);
}
}
public void applyGlobalDefaults() public void setOwner(String newOwner, boolean resetFlags) {
{ ResidenceOwnerChangeEvent ownerchange = new ResidenceOwnerChangeEvent(residence, newOwner);
this.clearFlags(); Residence.getServ().getPluginManager().callEvent(ownerchange);
FlagPermissions gRD = Residence.getConfigManager().getGlobalResidenceDefaultFlags(); owner = newOwner;
FlagPermissions gCD = Residence.getConfigManager().getGlobalCreatorDefaultFlags(); if (resetFlags) {
Map<String, FlagPermissions> gGD = Residence.getConfigManager().getGlobalGroupDefaultFlags(); this.applyDefaultFlags();
for(Entry<String, Boolean> entry : gRD.cuboidFlags.entrySet()) }
{ }
if(entry.getValue())
this.setFlag(entry.getKey(), FlagState.TRUE);
else
this.setFlag(entry.getKey(), FlagState.FALSE);
}
for(Entry<String, Boolean> entry : gCD.cuboidFlags.entrySet())
{
if(entry.getValue())
this.setPlayerFlag(owner, entry.getKey(), FlagState.TRUE);
else
this.setPlayerFlag(owner, entry.getKey(), FlagState.FALSE);
}
for(Entry<String, FlagPermissions> entry : gGD.entrySet())
{
for(Entry<String, Boolean> flag : entry.getValue().cuboidFlags.entrySet())
{
if(flag.getValue())
this.setGroupFlag(entry.getKey(), flag.getKey(), FlagState.TRUE);
else
this.setGroupFlag(entry.getKey(), flag.getKey(), FlagState.FALSE);
}
}
}
public boolean setFlagGroup(Player player, String flaggroup, String state, boolean resadmin) { public boolean setPlayerFlag(Player player, String targetPlayer, String flag, String flagstate, boolean resadmin) {
if (ResidencePermissions.validFlagGroups.containsKey(flaggroup)) { if (validFlagGroups.containsKey(flag))
ArrayList<String> flags = ResidencePermissions.validFlagGroups.get(flaggroup); return this.setFlagGroupOnPlayer(player, targetPlayer, flag, flagstate, resadmin);
boolean changed = false; FlagState state = FlagPermissions.stringToFlagState(flagstate);
for (String flag : flags) { if (checkCanSetFlag(player, flag, state, false, resadmin)) {
if (this.setFlag(player, flag, state, resadmin)) { ResidenceFlagChangeEvent fc = new ResidenceFlagChangeEvent(residence, player, flag,
changed = true; ResidenceFlagChangeEvent.FlagType.PLAYER, state, targetPlayer);
} Residence.getServ().getPluginManager().callEvent(fc);
} if (fc.isCancelled())
return changed; return false;
} if (super.setPlayerFlag(targetPlayer, flag, state)) {
return false; player.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("FlagSet"));
} return true;
}
}
return false;
}
public boolean setFlagGroupOnGroup(Player player, String flaggroup, String group, String state, boolean resadmin) { @Override
if (ResidencePermissions.validFlagGroups.containsKey(flaggroup)) { public boolean setPlayerFlag(String player, String flag, FlagState state) {
ArrayList<String> flags = ResidencePermissions.validFlagGroups.get(flaggroup); ResidenceFlagChangeEvent fc = new ResidenceFlagChangeEvent(residence, null, flag,
boolean changed = false; ResidenceFlagChangeEvent.FlagType.PLAYER, state, player);
for (String flag : flags) { Residence.getServ().getPluginManager().callEvent(fc);
if (this.setGroupFlag(player, group, flag, state, resadmin)) { if (fc.isCancelled())
changed = true; return false;
} return super.setPlayerFlag(player, flag, state);
} }
return changed;
}
return false;
}
public boolean setFlagGroupOnPlayer(Player player, String target, String flaggroup, String state, boolean resadmin) {
if (ResidencePermissions.validFlagGroups.containsKey(flaggroup)) {
ArrayList<String> flags = ResidencePermissions.validFlagGroups.get(flaggroup);
boolean changed = false;
for (String flag : flags) {
if (this.setPlayerFlag(player, target, flag, state, resadmin)) {
changed = true;
}
}
return changed;
}
return false;
}
} }