public void DataAPIGetItems()
{
// Arrange
JsonObject JsonResponse;
string endpoint = this.baseDataAPIUrl + "/itembank/items";
string action = "get";
JsonObject security = new JsonObject();
security.set("consumer_key", this.consumerKey);
security.set("domain", this.domain);
JsonObject request = new JsonObject();
request.set("limit", 3);
// Act
DataApi da = new DataApi();
Remote r = da.request(endpoint, security, this.consumerSecret, request, action);
JsonResponse = JsonObjectFactory.fromString(r.getBody());
// Assert
Assert.True(JsonResponse.getJsonObject("meta").getBool("status"));
}
public void inputJSONEqualsOutput()
{
string JSON = "{\"boolean\":true,\"integer\":1,\"decimal\":1.2,\"string\":\"string\",\"object\":{\"property\":null},\"array\":[null,[2]]}";
JsonObject jo = JsonObjectFactory.fromString(JSON);
string outputJSON = jo.toJson();
Assert.IsTrue(
JsonObjectFactory.JSONEquality(JSON, outputJSON),
"Input JSON (" + JSON + ") doesn't equal the output (" + outputJSON + ")"
);
JSON = "[0,1,2,3,4,5,6,7,8,9,10]";
jo = JsonObjectFactory.fromString(JSON);
outputJSON = jo.toJson();
Assert.IsTrue(
JsonObjectFactory.JSONEquality(JSON, outputJSON),
"Input JSON (" + JSON + ") doesn't equal the output (" + outputJSON + ")"
);
JSON = "[0,\"1\",2,\"3\",4,\"5\",6,\"7\",8,\"9\",10]";
jo = JsonObjectFactory.fromString(JSON);
outputJSON = jo.toJson();
Assert.IsTrue(
JsonObjectFactory.JSONEquality(JSON, outputJSON),
"Input JSON (" + JSON + ") doesn't equal the output (" + outputJSON + ")"
);
}
public static string Simple()
{
string uuid = Uuid.generate();
string courseId = "mycourse";
string questionsApiActivityJson = Assess.questionsApiActivity(uuid, courseId);
JsonObject questionsApiActivity = JsonObjectFactory.fromString(questionsApiActivityJson);
string service = "assess";
JsonObject security = new JsonObject();
security.set("consumer_key", Credentials.ConsumerKey);
security.set("user_id", "$ANONYMIZED_USER_ID");
security.set("domain", Credentials.Domain);
string secret = Credentials.ConsumerSecret;
JsonObject request = new JsonObject();
request.set("name", "Demo Activity (8 questions)");
request.set("state", "initial");
request.set("items", Assess.items(uuid));
request.set("questionsApiActivity", questionsApiActivity);
Init init = new Init(service, security, secret, request);
return(init.generate());
}
/// <summary>
/// Callback function with the same definition as defined delegate (ProcessData) in DataApi
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
private static bool DataApiRecursiveCallback(string data)
{
JsonObject jo = JsonObjectFactory.fromString(data);
if (jo != null)
{
return(true);
}
return(false);
}
/// <summary>
/// Makes a single request to the data api
/// </summary>
/// <param name="url">URL to send the request</param>
/// <param name="securityPacketJson">Security details</param>
/// <param name="secret">Private key</param>
/// <param name="requestPacketJson">Request packet</param>
/// <param name="action">Action for the request</param>
/// <param name="callback">Callback to process JSON data. Returning false in callback breaks from the loop of recursive requests.</param>
/// <returns>Instance of the Remote class</returns>
public JsonObject requestRecursive(string url, string securityPacketJson, string secret, string requestPacketJson = null, string action = null, ProcessData callback = null)
{
JsonObject securityPacket = JsonObjectFactory.fromString(securityPacketJson);
JsonObject requestPacket = null;
if (requestPacketJson != null)
{
requestPacket = JsonObjectFactory.fromString(requestPacketJson);
}
return(this.requestRecursive(url, securityPacket, secret, requestPacket, action, callback));
}
/// <summary>
/// Convert JSON strings into JsonObjects
/// </summary>
/// <param name="service"></param>
/// <param name="securityPacketJson"></param>
/// <param name="secret"></param>
/// <param name="requestPacketJson"></param>
/// <param name="action"></param>
private void Initialize(string service, string securityPacketJson, string secret, string requestPacketJson = null, string action = null)
{
JsonObject securityPacket = JsonObjectFactory.fromString(securityPacketJson);
JsonObject requestPacket;
if (requestPacketJson == null)
{
requestPacket = null;
}
else
{
requestPacket = JsonObjectFactory.fromString(requestPacketJson);
}
this.Initialize(service, securityPacket, secret, requestPacket, action);
}
public static string Simple(out string uuid)
{
uuid = Uuid.generate();
string courseId = "mycourse";
string service = "questions";
JsonObject security = new JsonObject();
security.set("consumer_key", Credentials.ConsumerKey);
security.set("domain", Credentials.Domain);
security.set("user_id", "$ANONYMIZED_USER_ID");
string secret = Credentials.ConsumerSecret;
JsonObject request = JsonObjectFactory.fromString(Questions.requestJson(uuid, courseId));
Init init = new Init(service, security, secret, request);
return(init.generate());
}
public static TestRequest getTestRequestFor(string service, string action = null)
{
JsonObject security = JsonObjectFactory.fromString(TestRequest.BaseSecurity);
JsonObject request = JsonObjectFactory.fromString(TestRequest.requests.GetValueOrDefault(service));
switch (service)
{
case "assess":
case "questions":
security.set("user_id", "$ANONYMIZED_USER_ID");
break;
case "items":
security.set("user_id", request.getString("user_id"));
break;
default:
// no changes
break;
}
return new TestRequest(service, security, request, action);
}
/// <summary>
/// Makes a single request to the data api
/// </summary>
/// <param name="url">URL to send the request</param>
/// <param name="securityPacket">Security details</param>
/// <param name="secret">Private key</param>
/// <param name="requestPacket">Request packet</param>
/// <param name="action">Action for the request</param>
/// <param name="callback">Callback to process JSON data. Returning false in callback breaks from the loop of recursive requests.</param>
/// <returns>Instance of the Remote class</returns>
private JsonObject handleRequestRecursive(string url, JsonObject securityPacket, string secret, JsonObject requestPacket = null, string action = null, ProcessData callback = null)
{
JsonObject response = new JsonObject(true);
JsonObject data, meta;
Remote request;
int recursion = 0;
do
{
request = this.request(url, securityPacket, secret, requestPacket, action);
data = JsonObjectFactory.fromString(request.getBody());
if (data == null)
{
throw new Exception("Request wasn't successful");
}
meta = data.getJsonObject("meta");
recursion++;
if (meta.getBool("status"))
{
if (callback != null)
{
// return if callback returns false
if (!callback(data.toJson()))
{
return(response);
}
}
else
{
response = Tools.array_merge(response, data.getJsonObject("data"));
}
}
else
{
throw new Exception(Json.encode(data));
}
if (Tools.array_key_exists("next", meta) && !Tools.empty(data.getJsonObject("data")))
{
string next = meta.getString("next");
if (next != null)
{
requestPacket.set("next", next);
securityPacket.remove("signature");
}
else
{
throw new Exception("data['meta']['next'] is not a string");
}
}
else
{
requestPacket.remove("next");
}
}while(Tools.array_key_exists("next", requestPacket));
return(response);
}
/// <summary>
/// Processing responseBody into JsonObject.
/// </summary>
private void process()
{
this.responseBodyJsonObject = JsonObjectFactory.fromString(this.responseBody);
}
public void RecursiveMergingJSONObjectsWorksProperly()
{
JsonObject jo1 = new JsonObject();
JsonObject jo1o = new JsonObject();
JsonObject jo1a = new JsonObject(true);
JsonObject jo1ao1 = new JsonObject();
JsonObject jo1ao2 = new JsonObject();
JsonObject jo2 = new JsonObject();
JsonObject jo2o = new JsonObject();
JsonObject jo2a = new JsonObject(true);
JsonObject jo2ao1 = new JsonObject();
JsonObject jo2ao2 = new JsonObject();
JsonObject joResult1 = new JsonObject();
JsonObject joResult2;
jo1.set("a", "a1");
jo1.set("b", "b1");
jo1.set("obj", jo1o);
jo1.set("arr", jo1a);
jo1o.set("d", "d1");
jo1o.set("e", "e1");
jo1a.set(true);
jo1a.setNull();
jo1a.set("string");
jo1a.set(1);
jo1a.set(1.2m);
jo1a.set(jo1ao1);
jo1a.set(jo1ao2);
jo1ao1.set("a", "a1");
jo1ao1.set("b", "b1");
jo1ao2.set("a", "a1");
jo1ao2.set("b", "b1");
jo2.set("a", "a2");
jo2.set("c", "c2");
jo2.set("obj", jo2o);
jo2.set("arr", jo2a);
jo2o.set("d", "d2");
jo2o.set("f", "f2");
jo2a.set(true);
jo2a.setNull();
jo2a.set("string");
jo2a.set(1);
jo2a.set(1.2m);
jo2a.set(jo2ao1);
jo2a.set(jo2ao2);
jo2ao1.set("a", "a2");
jo2ao1.set("b", "b2");
jo2ao2.set("a", "a2");
jo2ao2.set("b", "b2");
joResult1 = JsonObjectFactory.fromString(@"{
""a"": ""a1"",
""b"": ""b1"",
""c"": ""c2"",
""obj"": {
""d"": ""d1"",
""e"": ""e1"",
""f"": ""f2""
},
""arr"": [
true,
null,
""string"",
1,
1.2,
{
""a"": ""a1"",
""b"": ""b1""
},
{
""a"": ""a1"",
""b"": ""b1""
},
true,
null,
""string"",
1,
1.2,
{
""a"": ""a2"",
""b"": ""b2""
},
{
""a"": ""a2"",
""b"": ""b2""
}
]
}");
joResult2 = Tools.array_merge_recursive(jo1, jo2, false);
Assert.IsTrue(
JsonObjectFactory.JSONEquality(joResult1, joResult2),
"Merging of two objects recursively using the same property names doesn't work properly"
);
joResult1 = JsonObjectFactory.fromString(@"{
""a"": ""a2"",
""b"": ""b1"",
""c"": ""c2"",
""obj"": {
""d"": ""d2"",
""e"": ""e1"",
""f"": ""f2""
},
""arr"": [
true,
null,
""string"",
1,
1.2,
{
""a"": ""a1"",
""b"": ""b1""
},
{
""a"": ""a1"",
""b"": ""b1""
},
true,
null,
""string"",
1,
1.2,
{
""a"": ""a2"",
""b"": ""b2""
},
{
""a"": ""a2"",
""b"": ""b2""
}
]
}");
joResult2 = Tools.array_merge_recursive(jo1, jo2, true);
Assert.IsTrue(
JsonObjectFactory.JSONEquality(joResult1, joResult2),
"Merging of two objects recursively using the same property names with overwriting enabled doesn't work properly"
);
}