public static void setUpClass()
{
pc = new ParaClient("app:para", "ynJInh32zam7MzjBwBqwIVYtvm+tnsbBP1cpcq7PWmFhAmPsdua7HQ==");
pc.setEndpoint("http://localhost:8080");
pc2 = new ParaClient("app:para", null);
pc2.setEndpoint("http://localhost:8080");
if (pc.me() == null) {
throw new Exception("Local Para server must be started before testing.");
}
u = new ParaObject("111");
u.name = "John Doe";
u.tags = new List<string> { "one", "two", "three" };
u1 = new ParaObject("222");
u1.name = "Joe Black";
u1.tags = new List<string> { "two", "four", "three" };
u2 = new ParaObject("333");
u2.name = "Ann Smith";
u2.tags = new List<string> { "four", "five", "three" };
t = new ParaObject("tag:test", "tag");
t["count"] = 3;
t["tag"] = "test";
a1 = new ParaObject("adr1", "address");
a1.name = "Place 1";
a1["address"] = "NYC";
a1["country"] = "US";
a1["latlng"] = "40.67,-73.94";
a1.parentid = u.id;
a1.creatorid = u.id;
a2 = new ParaObject("adr2", "address");
a2.name = "Place 2";
a2["address"] = "NYC";
a2["country"] = "US";
a2["latlng"] = "40.69,-73.95";
a2.parentid = t.id;
a2.creatorid = t.id;
s1 = new ParaObject("s1");
s1.name = "This is a little test sentence. Testing, one, two, three.";
s2 = new ParaObject("s2");
s2.name = "We are testing this thing. This sentence is a test. One, two.";
pc.createAll(new List<ParaObject> { u, u1, u2, t, s1, s2, a1, a2 });
Thread.Sleep(1000);
}
public void testBatchCRUD()
{
List<ParaObject> dogs = new List<ParaObject>();
for (int i = 0; i < 3; i++)
{
ParaObject s = new ParaObject();
s.type = dogsType;
s["foo"] = "bark!";
dogs.Add(s);
}
Assert.IsTrue(pc.createAll(null).Count == 0);
List<ParaObject> l1 = pc.createAll(dogs);
Assert.AreEqual(3, l1.Count);
Assert.IsNotNull(l1[0].id);
Assert.IsTrue(pc.readAll(null).Count == 0);
List<string> nl = new List<string>(3);
Assert.IsTrue(pc.readAll(nl).Count == 0);
nl.Add(l1[0].id);
nl.Add(l1[1].id);
nl.Add(l1[2].id);
List<ParaObject> l2 = pc.readAll(nl);
Assert.AreEqual(3, l2.Count);
Assert.AreEqual(l1[0].id, l2[0].id);
Assert.AreEqual(l1[1].id, l2[1].id);
Assert.IsNotNull(l2[0]["foo"]);
Assert.AreEqual("bark!", l2[0]["foo"]);
Assert.IsTrue(pc.updateAll(null).Count == 0);
ParaObject part1 = new ParaObject(l1[0].id);
ParaObject part2 = new ParaObject(l1[1].id);
ParaObject part3 = new ParaObject(l1[2].id);
part1.type = dogsType;
part2.type = dogsType;
part3.type = dogsType;
part1["custom"] = "prop";
part1.name = "NewName1";
part2.name = "NewName2";
part3.name = "NewName3";
List<ParaObject> l3 = pc.updateAll(new List<ParaObject> { part1, part2, part3 });
Assert.IsNotNull(l3[0]["custom"]);
Assert.AreEqual(dogsType, l3[0].type);
Assert.AreEqual(dogsType, l3[1].type);
Assert.AreEqual(dogsType, l3[2].type);
Assert.AreEqual(part1.name, l3[0].name);
Assert.AreEqual(part2.name, l3[1].name);
Assert.AreEqual(part3.name, l3[2].name);
pc.deleteAll(nl);
Thread.Sleep(1000);
List<ParaObject> l4 = pc.list(dogsType);
Assert.IsTrue(l4.Count == 0);
Assert.IsTrue(((Dictionary<string, object>) pc.getApp()["datatypes"]).ContainsValue(dogsType));
}
/// <summary>
/// Links an object to this one in a many-to-many relationship.
/// Only a link is created. Objects are left untouched.
/// The type of the second object is automatically determined on read.
/// </summary>
/// <param name="obj">the object to execute this method on</param>
/// <param name="id2">link to the object with this id</param>
/// <returns>the id of the {@link com.erudika.para.core.Linker} object that is created</returns>
public string link(ParaObject obj, string id2)
{
if (obj == null || obj.id == null || id2 == null)
{
return null;
}
string url = obj.getObjectURI() + "/links/" + id2;
return (string) getEntity(invokePost(url, null), true);
}
/// <summary>
/// Checks if a given object is linked to this one.
/// </summary>
/// <param name="obj">the object to execute this method on</param>
/// <param name="toObj">the other object</param>
/// <returns>true if linked</returns>
public bool isLinked(ParaObject obj, ParaObject toObj)
{
if (obj == null || obj.id == null || toObj == null || toObj.id == null)
{
return false;
}
return isLinked(obj, toObj.type, toObj.id);
}
/// <summary>
/// Checks if this object is linked to another.
/// </summary>
/// <param name="obj">the object to execute this method on</param>
/// <param name="type2">the other type</param>
/// <param name="id2">the other id</param>
/// <returns>true if the two are linked</returns>
public bool isLinked(ParaObject obj, string type2, string id2)
{
if (obj == null || obj.id == null || type2 == null || id2 == null)
{
return false;
}
string url = obj.getObjectURI() + "/links/" + type2 + "/" + id2;
return bool.Parse((string) getEntity(invokeGet(url, null), true));
}
/// <summary>
/// Returns all objects linked to the given one. Only applicable to many-to-many relationships.
/// </summary>
/// <param name="obj">the object to execute this method on</param>
/// <param name="type2">type of linked objects to search for</param>
/// <param name="pager">a Pager</param>
/// <returns>a list of linked objects</returns>
public List<ParaObject> getLinkedObjects(ParaObject obj, string type2, params Pager[] pager)
{
if (obj == null || obj.id == null || type2 == null)
{
return new List<ParaObject>(0);
}
string url = obj.getObjectURI() + "/links/" + type2;
return getItems(getEntity(invokeGet(url, pagerToParams(pager)), true), pager);
}
/// <summary>
/// Unlinks an object from this one.
/// Only a link is deleted. Objects are left untouched.
/// </summary>
/// <param name="obj">the object to execute this method on</param>
/// <param name="type2">the other type</param>
/// <param name="id2">the other id</param>
public void unlink(ParaObject obj, string type2, string id2)
{
if (obj == null || obj.id == null || type2 == null || id2 == null)
{
return;
}
string url = obj.getObjectURI() + "/links/" + type2 + "/" + id2;
invokeDelete(url, null);
}
/// <summary>
/// Deletes all child objects permanently.
/// </summary>
/// <param name="obj">the object to execute this method on</param>
/// <param name="type2">the children's type.</param>
public void deleteChildren(ParaObject obj, string type2)
{
if (obj == null || obj.id == null || type2 == null)
{
return;
}
var paramz = new Dictionary<string, object>();
paramz["childrenonly"] = "true";
string url = obj.getObjectURI() + "/links/" + type2;
invokeDelete(url, paramz);
}
/////////////////////////////////////////////
// PERSISTENCE
/////////////////////////////////////////////
/// <summary>
/// Persists an object to the data store. If the object's type and id are given,
/// then the request will be a PUT request and any existing object will be overwritten.
/// </summary>
/// <param name="obj">the domain object</param>
/// <returns>the same object with assigned id or null if not created.</returns>
public ParaObject create(ParaObject obj)
{
if (obj == null)
{
return null;
}
if (string.IsNullOrEmpty(obj.id) || string.IsNullOrEmpty(obj.type))
{
return (ParaObject) getEntity(invokePost(obj.type, obj), false);
}
else
{
return (ParaObject) getEntity(invokePut(obj.type + "/" + obj.id, obj), false);
}
}
/// <summary>
/// Deletes an object permanently.
/// </summary>
/// <param name="obj">the object to delete</param>
public void delete(ParaObject obj)
{
if (obj == null)
{
return;
}
invokeDelete(obj.getObjectURI(), null);
}
/////////////////////////////////////////////
// LINKS
/////////////////////////////////////////////
/// <summary>
/// Count the total number of links between this object and another type of object.
/// </summary>
/// <param name="obj">the object to execute this method on</param>
/// <param name="type2">the other type of object</param>
/// <returns>the number of links for the given object</returns>
public long countLinks(ParaObject obj, string type2)
{
if (obj == null || obj.id == null || type2 == null)
{
return 0L;
}
var paramz = new Dictionary<string, object>();
paramz["count"] = "true";
var pager = new Pager();
string url = obj.getObjectURI() + "/links/" + type2;
getItems(getEntity(invokeGet(url, paramz), true), pager);
return pager.count;
}
/// <summary>
/// Updates an object permanently. Supports partial updates.
/// </summary>
/// <param name="obj">the object to update</param>
/// <returns>the updated object</returns>
public ParaObject update(ParaObject obj)
{
if (obj == null)
{
return null;
}
return (ParaObject) getEntity(invokePatch(obj.getObjectURI(), obj), false);
}
/// <summary>
/// Unlinks all objects that are linked to this one.
/// Only Linker objects are deleted, other objects are left untouched.
/// </summary>
/// <param name="obj">the object to execute this method on</param>
public void unlinkAll(ParaObject obj)
{
if (obj == null || obj.id == null)
{
return;
}
string url = obj.getObjectURI() + "/links";
invokeDelete(url, null);
}
public void testCRUD()
{
Assert.IsNull(pc.create(null));
ParaObject t1 = pc.create(new ParaObject("test1", "tag"));
t1["tag"] = "test1";
Assert.IsNotNull(t1);
Assert.IsNull(pc.read(null, null));
Assert.IsNull(pc.read("", ""));
ParaObject trID = pc.read(t1.id);
Assert.IsNotNull(trID);
Assert.IsNotNull(trID.timestamp);
Assert.AreEqual(t1["tag"], trID["tag"]);
ParaObject tr = pc.read(t1.type, t1.id);
Assert.IsNotNull(tr);
Assert.IsNotNull(tr.timestamp);
Assert.AreEqual(t1["tag"], tr["tag"]);
tr["count"] = (Int64)15;
ParaObject tu = pc.update(tr);
Assert.IsNull(pc.update(new ParaObject("null")));
Assert.IsNotNull(tu);
Assert.AreEqual(tu["count"], tr["count"]);
Assert.IsNotNull(tu.updated);
ParaObject s = new ParaObject();
s.type = dogsType;
s["foo"] = "bark!";
s = pc.create(s);
ParaObject dog = pc.read(dogsType, s.id);
Assert.IsNotNull(dog["foo"]);
Assert.AreEqual("bark!", dog["foo"]);
pc.delete(t1);
pc.delete(dog);
Assert.IsNull(pc.read(tr.type, tr.id));
}
/// <summary>
/// Searches through all linked objects in many-to-many relationships.
/// </summary>
/// <param name="obj">the object to execute this method on</param>
/// <param name="type2">type of linked objects to search for</param>
/// <param name="field">the name of the field to target (within a nested field "nstd")</param>
/// <param name="query">a query string</param>
/// <param name="pager">a Pager</param>
/// <returns>a list of linked objects</returns>
public List<ParaObject> findLinkedObjects(ParaObject obj, string type2, string field, string query,
params Pager[] pager)
{
if (obj == null || obj.id == null || type2 == null)
{
return new List<ParaObject>(0);
}
var paramz = new Dictionary<string, object>();
paramz["field"] = field;
paramz["q"] = string.IsNullOrEmpty(query) ? "*" : query;
paramz.Concat(pagerToParams(pager));
string url = obj.getObjectURI() + "/links/" + type2;
return getItems(getEntity(invokeGet(url, paramz), true), pager);
}
public void testList()
{
List<ParaObject> cats = new List<ParaObject>();
for (int i = 0; i < 3; i++)
{
ParaObject s = new ParaObject(catsType + i);
s.type = catsType;
cats.Add(s);
}
pc.createAll(cats);
Thread.Sleep(1000);
Assert.IsTrue(pc.list(null).Count == 0);
Assert.IsTrue(pc.list("").Count == 0);
List<ParaObject> list1 = pc.list(catsType);
Assert.IsFalse(list1.Count == 0);
Assert.AreEqual(3, list1.Count);
Assert.AreEqual(typeof(ParaObject), list1[0].GetType());
List<ParaObject> list2 = pc.list(catsType, new Pager(2));
Assert.IsFalse(list2.Count == 0);
Assert.AreEqual(2, list2.Count);
List<string> nl = new List<string>(3);
nl.Add(cats[0].id);
nl.Add(cats[1].id);
nl.Add(cats[2].id);
pc.deleteAll(nl);
Assert.IsTrue(((Dictionary<string, object>) pc.getApp()["datatypes"]).ContainsValue(catsType));
}
/// <summary>
/// Returns all child objects linked to this object.
/// </summary>
/// <param name="obj">the object to execute this method on</param>
/// <param name="type2">the type of children to look for</param>
/// <param name="field">the field name to use as filter</param>
/// <param name="term">the field value to use as filter</param>
/// <param name="pager">a Pager</param>
/// <returns>a list of ParaObject in a one-to-many relationship with this object</returns>
public List<ParaObject> getChildren(ParaObject obj, string type2, string field, string term,
params Pager[] pager)
{
if (obj == null || obj.id == null || type2 == null)
{
return new List<ParaObject>(0);
}
var paramz = new Dictionary<string, object>();
paramz["childrenonly"] = "true";
paramz["field"] = field;
paramz["term"] = term;
paramz.Concat(pagerToParams(pager));
string url = obj.getObjectURI() + "/links/" + type2;
return getItems(getEntity(invokeGet(url, paramz), true), pager);
}
public void testValidationConstraints()
{
// Validations
string kittenType = "kitten";
Dictionary<string, object> constraints = pc.validationConstraints();
Assert.IsFalse(constraints.Count == 0);
Assert.IsTrue(constraints.ContainsKey("app"));
Assert.IsTrue(constraints.ContainsKey("user"));
Dictionary<string, Dictionary<string, Dictionary<string, object>>> constraint =
pc.validationConstraints("app");
Assert.IsFalse(constraint.Count == 0);
Assert.IsTrue(constraint.ContainsKey("app"));
Assert.AreEqual(1, constraint.Count);
pc.addValidationConstraint(kittenType, "paws", Constraint.required());
constraint = pc.validationConstraints(kittenType);
Assert.IsTrue(constraint[kittenType].ContainsKey("paws"));
ParaObject ct = new ParaObject("felix");
ct.type = kittenType;
ParaObject ct2 = null;
try {
// validation fails
ct2 = pc.create (ct);
} catch { }
Assert.IsNull(ct2);
ct["paws"] = "4";
Assert.IsNotNull(pc.create(ct));
pc.removeValidationConstraint(kittenType, "paws", "required");
constraint = pc.validationConstraints(kittenType);
Assert.IsFalse(constraint.ContainsKey(kittenType));
}
/////////////////////////////////////////////
// Access Tokens
/////////////////////////////////////////////
/// <summary>
/// Takes an identity provider access token and fetches the user data from that provider.
/// A new {@link User} object is created if that user doesn't exist.
/// Access tokens are returned upon successful authentication using one of the SDKs from
/// Facebook, Google, Twitter, etc.
/// <b>Note:</b> Twitter uses OAuth 1 and gives you a token and a token secret.
/// <b>You must concatenate them like this: <code>{oauth_token}:{oauth_token_secret}</code> and
/// use that as the provider access token.</b>
/// </summary>
/// <returns>a user ParaObject or null if something failed</returns>
/// <param name="provider">identity provider, e.g. 'facebook', 'google'...</param>
/// <param name="providerToken">access token from a provider like Facebook, Google, Twitter</param>
public ParaObject signIn(string provider, string providerToken)
{
if (!string.IsNullOrEmpty(provider) && !string.IsNullOrEmpty(providerToken)) {
var credentials = new Dictionary<string, string>();
credentials["appid"] = accessKey;
credentials["provider"] = provider;
credentials["token"] = providerToken;
var res = getEntity(invokePost(JWT_PATH, credentials), true);
var result = (res == null) ? null : JsonConvert.DeserializeObject
<Dictionary<string, Dictionary<string, object>>>((string) res);
if (result != null && result.ContainsKey("user") && result.ContainsKey("jwt")) {
var jwtData = result["jwt"];
var userData = result["user"];
tokenKey = (string) jwtData["access_token"];
tokenKeyExpires = (long) (jwtData["expires"] ?? -1);
tokenKeyNextRefresh = (long) (jwtData["refresh"] ?? -1);
var user = new ParaObject();
user.setFields(userData);
return user;
}
else
{
clearAccessToken();
}
}
return null;
}