public AccessType Permission(User user, IPermissible permissible)
{
lock (objLock_Permission)
{
AccessType t = AccessType.Denied;
List <Group> roles = user.Groups(true);
foreach (Group r in roles)
{
AccessType gt = r.Permission(user, permissible);
gt = t > gt ? AccessType.Denied : gt;
t = (AccessType)Math.Max((int)gt, (int)t);
if (r.ID == "Administrator")
{
gt = r.Permission(user, user);
t = gt != AccessType.Denied ? AccessType.Write : AccessType.Denied;
if (t == AccessType.Write)
{
return(t);
}
}
}
return(t);
}
}
public void Add(Group group, IPermissible permissible, Type type, AccessType accessType)
{
CleanMemory();
string tableName = permissionTableName;
string searchString = "GroupID = '" + group.ID + "' AND PermissibleID = '" + permissible.PermissibleID + "'";
string targetString = null;
DataTable table = Database.DB["CloudApp"].GetDataTable(tableName, targetString, searchString);
DataRowCollection rows = table.Rows;
if (rows.Count == 0)
{
DataRow r = table.NewRow();
r["PermissibleID"] = permissible.PermissibleID;
r["GroupID"] = group.ID;
r["Type"] = type.ToString();
r["AccessType"] = (int)accessType;
rows.Add(r);
Database.DB["CloudApp"].UpdateDataTable(table);
}
else
{
rows[0]["AccessType"] = (int)accessType;
Database.DB["CloudApp"].UpdateDataTable(table);
}
}
public DateTime Expiry(User user, Group group, IPermissible permissible)
{
lock (expiryLock)
{
string tableName = permissionTableName;
string searchString = "PermissibleID = '" + permissible.PermissibleID + "' AND GroupID = '" + group.ID + "'";
string targetString = null;
DataTable table = Database.DB["CloudApp"].GetDataTable(tableName, targetString, searchString);
DataRowCollection rows = table.Rows;
System.Diagnostics.Debug.WriteLine("Expiry: " + user + " " + group + " " + permissible);
if (rows.Count != 0)
{
foreach (DataRow row in rows)
{
string gid = (string)row["GroupID"];
DateTime expiry = DateTime.MaxValue;
if (table.Columns.Contains("Expiry"))
{
if (!(row["Expiry"] is DBNull))
{
expiry = (DateTime)row["Expiry"];
}
}
return(expiry);
}
}
return(DateTime.MaxValue);
}
}
public override bool Execute(CommandArguments args, IPermissible sender)
{
var name = args.NextString();
if (string.IsNullOrEmpty(name))
return false;
if (name.Length < AccountManager.MinNameLength || name.Length > AccountManager.MaxNameLength)
return false;
var password = args.NextString();
if (string.IsNullOrEmpty(password))
return false;
if (password.Length < AccountManager.MinPasswordLength || password.Length > AccountManager.MaxPasswordLength)
return false;
var email = args.NextString();
if (string.IsNullOrEmpty(email))
return false;
var box = args.NextEnum<ClientBoxLevel>() ?? ClientBoxLevel.Cataclysm;
var locale = args.NextEnum<ClientLocale>() ?? ClientLocale.English;
AccountManager.Instance.CreateAccount(name, password, email, box, locale);
return true;
}
public PermissionAttachmentInfo(IPermissible permissible, string permission, PermissionAttachment attachment, bool value)
{
this.Permissible = permissible;
this.Permission = permission;
this.Attachment = attachment;
this.Value = value;
}
public override bool Execute(CommandArguments args, IPermissible sender)
{
var commands = CommandManager.Instance.GetCommands();
foreach (var cmd in commands.Values.Distinct())
{
var perm = cmd.RequiredPermission;
if (sender != null && perm != null && !sender.HasPermission(perm))
continue;
var cmd1 = cmd;
var triggers = commands.Where(x => x.Value == cmd1).Select(x => x.Key).ToList();
var count = triggers.Count;
for (var i = 0; i < count; i++)
{
Console.Write(triggers[i]);
if (i < count - 1)
Console.Write("|");
}
Console.WriteLine(": {0}", cmd.Description);
}
return true;
}
public void Remove(IPermissible permissible)
{
if (Factory == null)
{
return;
}
Factory.Remove(this, permissible);
}
public DateTime Expiry(IPermissible permissible)
{
if (Factory == null)
{
return(DateTime.MaxValue);
}
return(Factory.Expiry(User.CurrentUser, this, permissible));
}
public AccessType Permission(IPermissible permissible)
{
if (Factory == null)
{
return(AccessType.Write);
}
return(Factory.Permission(User.CurrentUser, this, permissible));
}
public bool Exists(IPermissible permissible)
{
if (Factory == null)
{
return(false);
}
return(Factory.Exists(this, permissible));
}
public bool Exists(Group group, IPermissible permissible)
{
string tableName = permissionTableName;
string searchString = "GroupID = '" + group.ID + "' AND PermissibleID = '" + permissible.PermissibleID + "'";
string targetString = null;
DataTable table = Database.DB["CloudApp"].GetDataTable(tableName, targetString, searchString);
DataRowCollection rows = table.Rows;
return(rows.Count != 0);
}
public override bool Execute(CommandArguments args, IPermissible sender)
{
Console.WriteLine("Executing this command will permanently overwrite the entire database. Continue? (Y/N)");
var answer = Console.ReadLine().ToUpper().ToCharArray().SingleOrDefault();
if (answer == 'Y')
AccountApplication.Instance.AccountDbContext.Post(x => x.Schema.Create());
return true;
}
public override bool Execute(CommandArguments args, IPermissible sender)
{
var fileName = args.NextString();
if (string.IsNullOrEmpty(fileName))
return false;
AccountApplication.Instance.AccountDbContext.Post(x => x.Schema.Export(fileName));
return true;
}
public DateTime Expiry(User user, Group group, IPermissible permissible)
{
// lock (permLock)
{
var t0 = DateTime.Now;
loadData();
return(_Expiry(user, group, permissible));
}
}
public AccessType Permission(User user, Group group, IPermissible permissible)
{
var exp = Expiry(user, group, permissible);
if (exp.Date < DateTime.Today)
{
return(AccessType.Denied);
}
return(_Permission(user, group, permissible));
}
public void SubscribeToDefaultPerms(bool op, IPermissible permissible)
{
Dictionary <WeakReference, WeakReference> map = defSubs[op];
if (map == null)
{
defSubs.Add(op, new Dictionary <WeakReference, WeakReference>());
}
map.Add(new WeakReference(permissible), new WeakReference(true));
}
public void Add(IPermissible permissible, Type type, AccessType accessType, DateTime?expiry = null)
{
if (Factory == null)
{
return;
}
_db = new ConcurrentDictionary <string, ConcurrentDictionary <string, AccessType> >();
Factory.Add(this, permissible, type, accessType, expiry);
}
public PermissibleBase(IServerOperator opable)
{
this.opable = opable;
if (opable is IPermissible)
{
this.parent = (IPermissible)opable;
}
RecalculatePermissions();
}
public void SubscribeToPermission(string permission, IPermissible permissible)
{
string name = permission.ToLower();
Dictionary <WeakReference, WeakReference> map = permSubs[name];
if (map == null)
{
map = new Dictionary <WeakReference, WeakReference>();
permSubs.Add(name, map);
}
map.Add(new WeakReference(permissible), new WeakReference(true));
}
public void UnsubscribeFromDefaultPerms(bool op, IPermissible permissible)
{
Dictionary <WeakReference, WeakReference> map = defSubs[op];
if (map != null)
{
map.Remove(map.SingleOrDefault(p => (IPermissible)p.Value.Target == permissible).Value);
if (!map.Any())
{
defSubs.Remove(op);
}
}
}
public AccessType Permission(IPermissible permissible)
{
if (Factory == null)
{
return(AccessType.Write);
}
if (ID == "System")
{
return(AccessType.Write);
}
return(Factory.Permission(this, permissible));
}
public PermissionAttachment(IPlugin plugin, IPermissible Permissible)
{
if (plugin == null)
{
throw new ArgumentException("Plugin cannot be null");
}
else if (!plugin.IsEnabled())
{
throw new ArgumentException("Plugin " + plugin.GetPluginInfo().FullName + " is disabled");
}
this.permissible = Permissible;
this.plugin = plugin;
}
public void UnsubscribeFromPermission(string permission, IPermissible permissible)
{
string name = permission.ToLower();
Dictionary <WeakReference, WeakReference> map = permSubs[name];
if (map != null)
{
map.Remove(map.SingleOrDefault(p => (IPermissible)p.Value.Target == permissible).Value);
if (!map.Any())
{
permSubs.Remove(name);
}
}
}
public void Remove(Group group, IPermissible permissible)
{
CleanMemory();
string tableName = permissionTableName;
string searchString = "GroupID = '" + group.ID + "' AND PermissibleID = '" + permissible.PermissibleID + "'";
string targetString = null;
DataTable table = Database.DB["CloudApp"].GetDataTable(tableName, targetString, searchString);
DataRowCollection rows = table.Rows;
foreach (DataRow row in rows)
{
row.Delete();
}
Database.DB["CloudApp"].UpdateDataTable(table);
}
public PermissionAttachmentInfo(IPermissible permissible, string permission, PermissionAttachment attachment, bool value)
{
if (permissible == null)
{
throw new ArgumentException("Permissible may not be null");
}
else if (permission == null)
{
throw new ArgumentException("Permissions may not be null");
}
this.permissible = permissible;
this.permission = permission;
this.attachment = attachment;
this.value = value;
}
public static IPermissible FindPermissible(User user, Type type, string id)
{
if (type == typeof(User))
{
User u = User.FindUser(id);
return(u);
}
IPermissible p = FindPermissibleCustom(type, id);
if (p != null && user.Permission(p) != AccessType.Denied)
{
return(p);
}
return(null);
}
public AccessType Permission(User user, Group group, IPermissible permissible)
{
// lock (permLock)
{
var t0 = DateTime.Now;
loadData();
var exp = Expiry(user, group, permissible);
if (exp.Date < DateTime.Today)
{
return(AccessType.Denied);
}
if ((DateTime.Now - t0).TotalSeconds > 1)
{
Console.WriteLine(" ---- Permission: " + group.ID + " " + (DateTime.Now - t0));
}
return(_Permission(user, group, permissible));
}
}
public AccessType Permission(User user, IPermissible permissible)
{
if (Permission(User.CurrentUser) != AccessType.Write)
{
return(AccessType.Denied);
}
if (Factory == null)
{
return(AccessType.Write);
}
string ukey = user == null ? "" : user.PermissibleID;
if (permissible == null)
{
return(AccessType.Denied);
}
if (_db.ContainsKey(ukey) && _db[ukey].ContainsKey(permissible.PermissibleID))
{
return(_db[ukey][permissible.PermissibleID]);
}
AccessType type = Factory.Permission(user, this, permissible);
if (!_db.ContainsKey(ukey))
{
_db.TryAdd(ukey, new ConcurrentDictionary <string, AccessType>());
}
if (!_db[ukey].ContainsKey(permissible.PermissibleID))
{
_db[ukey].TryAdd(permissible.PermissibleID, type);
}
else
{
_db[ukey][permissible.PermissibleID] = type;
}
return(type);
}
public List <Group> Groups(User user, IPermissible permissible)
{
string tableName = permissionTableName;
string searchString = "PermissibleID = '" + permissible.PermissibleID + "'";
string targetString = null;
DataTable table = Database.DB["CloudApp"].GetDataTable(tableName, targetString, searchString);
DataRowCollection rows = table.Rows;
List <Group> result = new List <Group>();
if (rows.Count != 0)
{
foreach (DataRow row in rows)
{
string id = (string)row["GroupID"];
result.Add(FindGroup(user, id));
}
}
return(result);
}
public void Add(Group group, IPermissible permissible, Type type, AccessType accessType, DateTime?expiry)
{
lock (permLock)
{
CleanMemory();
string tableName = permissionTableName;
string searchString = "GroupID = '" + group.ID + "' AND PermissibleID = '" + permissible.PermissibleID + "'";
string targetString = null;
DataTable table = Database.DB["CloudApp"].GetDataTable(tableName, targetString, searchString);
DataRowCollection rows = table.Rows;
if (rows.Count == 0)
{
DataRow r = table.NewRow();
r["PermissibleID"] = permissible.PermissibleID;
r["GroupID"] = group.ID;
r["Type"] = type.ToString();
r["AccessType"] = (int)accessType;
if (table.Columns.Contains("Expiry") && expiry.HasValue)
{
r["Expiry"] = expiry.Value;
}
rows.Add(r);
Database.DB["CloudApp"].UpdateDataTable(table);
}
else
{
rows[0]["AccessType"] = (int)accessType;
if (table.Columns.Contains("Expiry") && expiry.HasValue)
{
rows[0]["Expiry"] = expiry.Value;
}
Database.DB["CloudApp"].UpdateDataTable(table);
}
loadData();
}
}
/// <summary> /// Executes the command. /// </summary> /// <param name="args">The arguments to the command.</param> /// <param name="sender">The sender of the command (may be null in the case of the console).</param> /// <returns>Whether or not arguments were valid.</returns> public abstract bool Execute(CommandArguments args, IPermissible sender);
public static List <Group> Groups(IPermissible permissible)
{
return(Factory.Groups(User.CurrentUser, permissible));
}
public DateTime Expiry(User user, IPermissible permissible)
{
return(Factory.Expiry(user, this, permissible));
}
public List <IPermissible> List(User user, Group group, Type type, AccessType accessType, bool aggregated)
{
lock (list2Lock)
{
string key = user.ID + group.ID + type + accessType + aggregated;
if (_listPermissibleTypeAccessType.ContainsKey(key))
{
return(_listPermissibleTypeAccessType[key]);
}
List <IPermissible> result = new List <IPermissible>();
if (aggregated)
{
List <Group> subgroups = group.SubGroups(user, aggregated);
if (subgroups != null)
{
foreach (Group sg in subgroups)
{
List <IPermissible> ips = sg.List(type, accessType, false);
if (ips != null)
{
foreach (IPermissible ip in ips)
{
if (!result.Contains(ip))
{
result.Add(ip);
}
}
}
}
}
}
if (_rawPermissibleDB.Count == 0)
{
string tableName = permissionTableName;
string searchString = null;
string targetString = null;
DataTable table = Database.DB["CloudApp"].GetDataTable(tableName, targetString, searchString);
DataRowCollection rows = table.Rows;
System.Diagnostics.Debug.WriteLine("List: " + user + " " + group + " " + type);
if (rows.Count != 0)
{
foreach (DataRow row in rows)
{
string gid = (string)row["GroupID"];
if (!_rawPermissibleDB.ContainsKey(gid))
{
_rawPermissibleDB.TryAdd(gid, new ConcurrentDictionary <string, AccessType>());
}
if (!_rawPermissibleTypeDB.ContainsKey(gid))
{
_rawPermissibleTypeDB.TryAdd(gid, new ConcurrentDictionary <string, string>());
}
_rawPermissibleDB[gid].TryAdd((string)row["PermissibleID"], (AccessType)row["AccessType"]);
_rawPermissibleTypeDB[gid].TryAdd((string)row["PermissibleID"], (string)row["Type"]);
}
}
}
else
{
if (_rawPermissibleTypeDB.ContainsKey(group.ID))
{
foreach (string pid in _rawPermissibleTypeDB[group.ID].Keys.ToList())
{
if (_rawPermissibleTypeDB[group.ID][pid] == type.ToString() && (int)_rawPermissibleDB[group.ID][pid] >= (int)accessType)
{
IPermissible permissible = Group.FindPermissible(user, type, pid);
if (permissible != null && !result.Contains(permissible))
{
result.Add(permissible);
}
}
}
}
}
try
{
if (result.Count > 0)
{
_listPermissibleTypeAccessType.TryAdd(key, result);
}
}
catch { }
return(result);
}
}
public AccessType Permission(User user, Group group, IPermissible permissible)
{
lock (permLock)
{
AccessType type = AccessType.Denied;
if (group.Parent != null)
{
AccessType pt = Permission(user, group.Parent, permissible);
if (pt == AccessType.Write)
{
type = AccessType.Write;
}
}
string uid = user == null ? "" : user.ID;
if (_permissibleDB.ContainsKey(uid) && _permissibleDB[uid].ContainsKey(group.ID) && _permissibleDB[uid][group.ID].ContainsKey(permissible.PermissibleID))
{
return(_permissibleDB[uid][group.ID][permissible.PermissibleID]);
}
if (!_permissibleDB.ContainsKey(uid))
{
_permissibleDB.TryAdd(uid, new ConcurrentDictionary <string, ConcurrentDictionary <string, AccessType> >());
}
if (!_permissibleDB[uid].ContainsKey(group.ID))
{
_permissibleDB[uid].TryAdd(group.ID, new ConcurrentDictionary <string, AccessType>());
}
if (user != null && user.PermissibleID == "System")
{
type = AccessType.Write;
}
if (permissible == null)
{
return(AccessType.Denied);
}
if (type != AccessType.Write)
{
type = group.ID == "Administrator" ? AccessType.Denied : FindGroup(User.CurrentUser, "Administrator").Permission(user, permissible);
if (type == AccessType.Write)
{
if (!_permissibleDB[uid][group.ID].ContainsKey(permissible.PermissibleID))
{
_permissibleDB[uid][group.ID].TryAdd(permissible.PermissibleID, type);
}
return(type);
}
if (type == AccessType.Denied)
{
if (_rawPermissibleDB.Count == 0)
{
_rawPermissibleDB.TryAdd(group.ID, new ConcurrentDictionary <string, AccessType>());
_rawPermissibleTypeDB.TryAdd(group.ID, new ConcurrentDictionary <string, string>());
string tableName = permissionTableName;
string searchString = null;
string targetString = null;
DataTable table = Database.DB["CloudApp"].GetDataTable(tableName, targetString, searchString);
DataRowCollection rows = table.Rows;
System.Diagnostics.Debug.WriteLine("Permission: " + user + " " + group + " " + permissible + " " + type);
if (rows.Count != 0)
{
foreach (DataRow row in rows)
{
string gid = (string)row["GroupID"];
if (!_rawPermissibleDB.ContainsKey(gid))
{
_rawPermissibleDB.TryAdd(gid, new ConcurrentDictionary <string, AccessType>());
}
if (!_rawPermissibleTypeDB.ContainsKey(gid))
{
_rawPermissibleTypeDB.TryAdd(gid, new ConcurrentDictionary <string, string>());
}
_rawPermissibleDB[gid].TryAdd((string)row["PermissibleID"], (AccessType)row["AccessType"]);
_rawPermissibleTypeDB[gid].TryAdd((string)row["PermissibleID"], (string)row["Type"]);
}
}
}
if (_rawPermissibleDB.ContainsKey(group.ID))
{
if (_rawPermissibleDB[group.ID].ContainsKey(permissible.PermissibleID))
{
type = _rawPermissibleDB[group.ID][permissible.PermissibleID];
}
else
{
return(type);
}
}
else
{
return(type);
}
if (group.Parent != null)
{
AccessType pt = Permission(user, group.Parent, permissible);
if (pt == AccessType.Write)
{
type = AccessType.Write;
}
}
}
if (!(permissible is User))
{
AccessType gtype = group.Permission(user, user);
if (user != null)
{
type = type > gtype ? AccessType.Denied : gtype;
}
}
}
if (user == null)
{
return(type);
}
if (!_permissibleDB.ContainsKey(uid))
{
_permissibleDB.TryAdd(uid, new ConcurrentDictionary <string, ConcurrentDictionary <string, AccessType> >());
}
if (!_permissibleDB[uid].ContainsKey(group.ID))
{
_permissibleDB[uid].TryAdd(group.ID, new ConcurrentDictionary <string, AccessType>());
}
if (!_permissibleDB[uid][group.ID].ContainsKey(permissible.PermissibleID))
{
_permissibleDB[uid][group.ID].TryAdd(permissible.PermissibleID, type);
}
return(type);
}
}
public override bool Execute(CommandArguments args, IPermissible sender)
{
Contract.Requires(args != null);
return false;
}
public override bool Execute(CommandArguments args, IPermissible sender)
{
CommandConsole.StopConsole = true;
return true;
}
