public static object EncodeACL(ParseACL acl)
{
HashSet <string> keys = new HashSet <string>();
if (acl.readAccess.Count > 0)
{
keys.UnionWith(acl.readAccess.Keys);
}
if (acl.writeAccess.Count > 0)
{
keys.UnionWith(acl.writeAccess.Keys);
}
Dictionary <string, object> result = new Dictionary <string, object>();
foreach (string key in keys)
{
Dictionary <string, bool> access = new Dictionary <string, bool>();
if (acl.readAccess.TryGetValue(key, out bool ra))
{
access["read"] = ra;
}
if (acl.writeAccess.TryGetValue(key, out bool wa))
{
access["write"] = wa;
}
result[key] = access;
}
return(result);
}
public void TestIndexGetterSetter()
{
ParseObject obj = ParseObject.Create("Corgi");
obj["gogo"] = true;
obj["list"] = new List <string>();
obj["dict"] = new Dictionary <string, object>();
obj["fakeACL"] = new ParseACL();
obj["obj"] = new ParseObject("Corgi");
Assert.True(obj.ContainsKey("gogo"));
Assert.IsInstanceOf <bool>(obj["gogo"]);
Assert.True(obj.ContainsKey("list"));
Assert.IsInstanceOf <IList <string> >(obj["list"]);
Assert.True(obj.ContainsKey("dict"));
Assert.IsInstanceOf <IDictionary <string, object> >(obj["dict"]);
Assert.True(obj.ContainsKey("fakeACL"));
Assert.IsInstanceOf <ParseACL>(obj["fakeACL"]);
Assert.True(obj.ContainsKey("obj"));
Assert.IsInstanceOf <ParseObject>(obj["obj"]);
Assert.Throws <KeyNotFoundException>(() => { var gogo = obj["missingItem"]; });
}
public void TestIndexGetterSetter()
{
ParseObject obj = Client.CreateObject("Corgi");
obj["gogo"] = true;
obj["list"] = new List <string>();
obj["dict"] = new Dictionary <string, object>();
obj["fakeACL"] = new ParseACL();
obj[nameof(obj)] = new ParseObject("Corgi");
Assert.IsTrue(obj.ContainsKey("gogo"));
Assert.IsInstanceOfType(obj["gogo"], typeof(bool));
Assert.IsTrue(obj.ContainsKey("list"));
Assert.IsInstanceOfType(obj["list"], typeof(IList <string>));
Assert.IsTrue(obj.ContainsKey("dict"));
Assert.IsInstanceOfType(obj["dict"], typeof(IDictionary <string, object>));
Assert.IsTrue(obj.ContainsKey("fakeACL"));
Assert.IsInstanceOfType(obj["fakeACL"], typeof(ParseACL));
Assert.IsTrue(obj.ContainsKey(nameof(obj)));
Assert.IsInstanceOfType(obj[nameof(obj)], typeof(ParseObject));
Assert.ThrowsException <KeyNotFoundException>(() => { object gogo = obj["missingItem"]; });
}
public async Task UserReadAndWrite()
{
await ParseUser.Login("hello", "world");
ParseObject account = new ParseObject("Account");
ParseUser currentUser = await ParseUser.GetCurrent();
ParseACL acl = ParseACL.CreateWithOwner(currentUser);
account.ACL = acl;
account["balance"] = 512;
await account.Save();
Assert.IsTrue(acl.GetUserReadAccess(currentUser));
Assert.IsTrue(acl.GetUserWriteAccess(currentUser));
ParseQuery <ParseObject> query = new ParseQuery <ParseObject>("Account");
ParseObject result = await query.Get(account.ObjectId);
TestContext.WriteLine(result.ObjectId);
Assert.NotNull(result.ObjectId);
await ParseUser.Logout();
result = await query.Get(account.ObjectId);
Assert.IsNull(result);
}
public void TestACLCoding()
{
MutableObjectState state = (MutableObjectState)ParseObjectCoder.Instance.Decode(new Dictionary <string, object>
{
["ACL"] = new Dictionary <string, object>
{
["3KmCvT7Zsb"] = new Dictionary <string, object>
{
["read"] = true,
["write"] = true
},
["*"] = new Dictionary <string, object> {
["read"] = true
}
}
}, null);
ParseACL resultACL = null;
Assert.IsTrue(state.ContainsKey("ACL"));
Assert.IsTrue((resultACL = state.ServerData["ACL"] as ParseACL) is ParseACL);
Assert.IsTrue(resultACL.PublicReadAccess);
Assert.IsFalse(resultACL.PublicWriteAccess);
Assert.IsTrue(resultACL.GetWriteAccess("3KmCvT7Zsb"));
Assert.IsTrue(resultACL.GetReadAccess("3KmCvT7Zsb"));
Assert.IsFalse(resultACL.GetWriteAccess("*"));
Assert.IsTrue(resultACL.GetReadAccess("*"));
}
public void TestEncodeACL()
{
ParseACL acl1 = new ParseACL();
IDictionary <string, object> value1 = ParseEncoderTestClass.Instance.Encode(acl1, Client) as IDictionary <string, object>;
Assert.IsNotNull(value1);
Assert.AreEqual(0, value1.Keys.Count);
ParseACL acl2 = new ParseACL
{
PublicReadAccess = true,
PublicWriteAccess = true
};
IDictionary <string, object> value2 = ParseEncoderTestClass.Instance.Encode(acl2, Client) as IDictionary <string, object>;
Assert.AreEqual(1, value2.Keys.Count);
IDictionary <string, object> publicAccess = value2["*"] as IDictionary <string, object>;
Assert.AreEqual(2, publicAccess.Keys.Count);
Assert.IsTrue((bool)publicAccess["read"]);
Assert.IsTrue((bool)publicAccess["write"]);
// TODO (hallucinogen): mock ParseUser and test SetReadAccess and SetWriteAccess
}
public void Initialize()
{
ACL = new ParseACL();
Readers = new ParseRole(ObjectId + "_Readers", ACL);
Writers = new ParseRole(ObjectId + "_Writers", ACL);
ACL.SetRoleReadAccess(Readers, true);
ACL.SetRoleReadAccess(Writers, true);
ACL.SetRoleWriteAccess(Writers, true);
}
public void TestCheckPermissionsWithParseUserConstructor()
{
ParseUser owner = GenerateUser("OwnerUser");
ParseUser user = GenerateUser("OtherUser");
ParseACL acl = new ParseACL(owner);
Assert.IsTrue(acl.GetReadAccess(owner.ObjectId));
Assert.IsTrue(acl.GetWriteAccess(owner.ObjectId));
Assert.IsTrue(acl.GetReadAccess(owner));
Assert.IsTrue(acl.GetWriteAccess(owner));
}
public async Task PrivateReadAndWrite()
{
ParseObject account = new ParseObject("Account");
ParseACL acl = new ParseACL();
acl.PublicReadAccess = false;
acl.PublicWriteAccess = false;
account.ACL = acl;
account["balance"] = 1024;
await account.Save();
Assert.IsFalse(acl.PublicReadAccess);
Assert.IsFalse(acl.PublicWriteAccess);
}
public async Task RoleReadAndWrite()
{
ParseQuery <ParseRole> query = ParseRole.GetQuery();
ParseRole owner = await query.Get("5e1440cbfc36ed006add1b8d");
ParseObject account = new ParseObject("Account");
ParseACL acl = new ParseACL();
acl.SetRoleReadAccess(owner, true);
acl.SetRoleWriteAccess(owner, true);
account.ACL = acl;
await account.Save();
Assert.IsTrue(acl.GetRoleReadAccess(owner));
Assert.IsTrue(acl.GetRoleWriteAccess(owner));
}
public void TestReadWriteMutationWithParseUserConstructor()
{
ParseUser owner = GenerateUser("OwnerUser");
ParseUser otherUser = GenerateUser("OtherUser");
ParseACL acl = new ParseACL(owner);
acl.SetReadAccess(otherUser, true);
acl.SetWriteAccess(otherUser, true);
acl.SetReadAccess(owner.ObjectId, false);
acl.SetWriteAccess(owner.ObjectId, false);
Assert.IsTrue(acl.GetReadAccess(otherUser.ObjectId));
Assert.IsTrue(acl.GetWriteAccess(otherUser.ObjectId));
Assert.IsTrue(acl.GetReadAccess(otherUser));
Assert.IsTrue(acl.GetWriteAccess(otherUser));
Assert.IsFalse(acl.GetReadAccess(owner));
Assert.IsFalse(acl.GetWriteAccess(owner));
}
public static ParseACL DecodeACL(Dictionary <string, object> dict)
{
ParseACL acl = new ParseACL();
foreach (KeyValuePair <string, object> kv in dict)
{
string key = kv.Key;
Dictionary <string, object> access = kv.Value as Dictionary <string, object>;
if (access.TryGetValue("read", out object ra))
{
acl.readAccess[key] = Convert.ToBoolean(ra);
}
if (access.TryGetValue("write", out object wa))
{
acl.writeAccess[key] = Convert.ToBoolean(wa);
}
}
return(acl);
}
IEnumerator CreateTeamCoroutine(string name)
{
LoadAlert.Instance.StartLoad("Creating " + name + "...", null, -1);
ParseACL acl = new ParseACL(ParseUser.CurrentUser);
ParseRole role = new ParseRole(name, acl);
role.Users.Add(ParseUser.CurrentUser);
User.CurrentUser.CompanyName = name;
Task task = role.SaveAsync();
while (!task.IsCompleted)
{
yield return(null);
}
if (task.IsFaulted || task.Exception != null)
{
Debug.Log("error:\n" + task.Exception.ToString());
}
else
{
task = ParseUser.CurrentUser.SaveAsync();
while (!task.IsCompleted)
{
yield return(null);
}
if (task.IsFaulted || task.Exception != null)
{
Debug.Log("error:\n" + task.Exception.ToString());
}
else
{
TeamUpdated(role);
}
}
}
public static bool Initialize()
{
try {
var credentials = Accredit.GetCredentials("benchmarker");
// Xamarin Performance
InitializeParseForXamarinPerformance();
var user = AsyncContext.Run(() => ParseInterface.RunWithRetry(() => ParseUser.LogInAsync(credentials ["username"].ToString(), credentials ["password"].ToString())));
//Console.WriteLine ("LogInAsync");
//Console.WriteLine ("User authenticated: " + user.IsAuthenticated);
var acl = new ParseACL(user);
acl.PublicReadAccess = true;
acl.PublicWriteAccess = false;
defaultACL = acl;
} catch (Exception e) {
Console.Error.WriteLine("Error: Exception when initializing Parse API: {0}", e);
return(false);
}
return(true);
}
