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());
}
public void MergingJSONObjectsWorksProperly()
{
JsonObject jo1 = new JsonObject();
JsonObject jo2 = new JsonObject();
JsonObject jo3 = new JsonObject();
JsonObject joResult1 = new JsonObject();
jo1.set("a", "a");
jo1.set("b", "b");
jo1.set("c", "c");
jo2.set("d", "d");
jo2.set("e", "e");
jo2.set("f", "f");
jo3.set("a", "d");
jo3.set("b", "e");
jo3.set("c", "f");
joResult1.set("a", "a");
joResult1.set("b", "b");
joResult1.set("c", "c");
joResult1.set("d", "d");
joResult1.set("e", "e");
joResult1.set("f", "f");
JsonObject joResult2 = Tools.array_merge(jo1, jo2);
Assert.IsTrue(
JsonObjectFactory.JSONEquality(joResult1, joResult2),
"Merging of two objects doesn't work properly"
);
joResult1 = new JsonObject();
joResult1.set("a", "a");
joResult1.set("b", "b");
joResult1.set("c", "c");
joResult2 = Tools.array_merge(jo1, jo3);
Assert.IsTrue(
JsonObjectFactory.JSONEquality(joResult1, joResult2),
"Merging of two objects doesn't work properly"
);
joResult1 = new JsonObject();
joResult1.set("a", "d");
joResult1.set("b", "e");
joResult1.set("c", "f");
joResult2 = Tools.array_merge(jo1, jo3, true);
// overwrite works for objects
Assert.IsTrue(
JsonObjectFactory.JSONEquality(joResult1, joResult2),
"Merging of two objects using the same property names with overwriting enabled doesn't work properly"
);
}
public override void Execute(object parameter)
{
string jsonString = ClipboardManager.TryGetText();
Debug.Assert(JsonObjectFactory.TryAgressiveDeserialize(jsonString).Result.IsSuccessful());
this.MainWindow.Raw_TextBox.Text = jsonString;
this.MainWindow.SetDisplayMode(MainWindow.DisplayMode.TreeView);
this.Update();
}
private void JsonObjectTest()
{
//创建一个JsonObject对象
var jsonObj = JsonObjectFactory.CreateJsonObject(Resources.Load <TextAsset>("test").text);
Debug.Log("----------------转换为JSON---------------");
Debug.Log(jsonObj.ToJson());
Debug.Log("----------------判断code属性是否存在---------------");
Debug.Log(jsonObj.ContainsKey("code"));
Debug.Log("----------------获取子对象data---------------");
Debug.Log("获取子对象data:" + jsonObj["data"].ToJson());
Debug.Log("----------------获取子对象data的name属性---------------");
Debug.Log("获取子对象data的name字段:" + jsonObj["data"]["name"].GetString());
Debug.Log("----------------修改data的值---------------");
jsonObj["data"] = new JsonObject(1);
Debug.Log("----------------修改后data的值---------------");
Debug.Log(jsonObj["data"].GetNumber());
Debug.Log("----------------添加一个新的Number属性test add num---------------");
jsonObj.Add("test add num", 1);
Debug.Log(jsonObj["test add num"].GetNumber());
Debug.Log("----------------添加一个新的boolean属性test add boolean---------------");
jsonObj.Add("test add boolean", false);
Debug.Log(jsonObj["test add boolean"].GetBoolean());
Debug.Log("----------------添加一个新的string属性---------------");
jsonObj.Add("test add string", "new string");
Debug.Log(jsonObj["test add string"].GetString());
Debug.Log("----------------添加一个数组属性test add array---------------");
var array = new JsonObject();
array.Add(1);
array.Add(2);
array.Add(3);
jsonObj.Add("test add array", array);
Debug.Log(jsonObj["test add array"].ToJson());
Debug.Log("----------------添加一个object属性test add subObject---------------");
var subObj = new JsonObject();
subObj.Add("sub obj num", 1);
subObj.Add("sub obj boolean", false);
jsonObj.Add("test add subObject", subObj);
Debug.Log(jsonObj["test add subObject"].ToJson());
Debug.Log("----------------修改后的json---------------");
Debug.Log(jsonObj.ToJson());
Debug.Log("----------------遍历所有根属性---------------");
foreach (var item in jsonObj)
{
Debug.Log(item.Key + ":" + item.Value);
}
var helloWorldJsonObj = JsonObjectFactory.CreateJsonObject("{}");
JsonUtility.FromJson <HelloWorld>(helloWorldJsonObj.ToJson());
Debug.Log((char)0x1f);
}
public IRestResponse <TRequest> Execute <TRequest>(IRestRequest request)
where TRequest : class
{
var mockResponse = new Mock <IRestResponse <TRequest> >();
var mockData = JsonObjectFactory.Get <TRequest>();
mockResponse.SetupGet(r => r.Data)
.Returns(mockData.Object);
_calls.Add(typeof(TRequest));
return(mockResponse.Object);
}
/// <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>
/// Generate the data necessary to make a request to quesetions service.
/// </summary>
/// <param name="output"></param>
/// <returns></returns>
private JsonObject generateQuestions(JsonObject output)
{
output = this.securityPacket;
output.remove("domain");
if (!Tools.empty(this.requestPacket))
{
output = JsonObjectFactory.merge(output, this.requestPacket, false, false);
}
return(output);
}
private async void Update()
{
string jsonString = ClipboardManager.TryGetText();
bool possible = !string.IsNullOrWhiteSpace(jsonString) && this.MainWindow.Raw_TextBox.Text != jsonString;
if (possible)
{
DeserializeResult deserializeResult = await JsonObjectFactory.TryAgressiveDeserialize(jsonString);
this.SetCanExecute(deserializeResult.IsSuccessful());
}
else
{
this.SetCanExecute(false);
}
}
/// <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 void MergingJSONArraysWorksProperly()
{
JsonObject ja1 = new JsonObject(true);
JsonObject ja2 = new JsonObject(true);
JsonObject jaResult1 = new JsonObject(true);
ja1.set("a");
ja1.set("b");
ja1.set("c");
ja2.set("d");
ja2.set("e");
ja2.set("f");
jaResult1.set("a");
jaResult1.set("b");
jaResult1.set("c");
jaResult1.set("d");
jaResult1.set("e");
jaResult1.set("f");
JsonObject jaResult2 = Tools.array_merge(ja1, ja2);
Assert.IsTrue(
JsonObjectFactory.JSONEquality(jaResult1, jaResult2),
"Merging of two arrays doesn't work properly"
);
jaResult1 = new JsonObject(true);
jaResult1.set("d");
jaResult1.set("e");
jaResult1.set("f");
jaResult2 = Tools.array_merge(ja1, ja2, true);
// overwrite should only work for objects
Assert.IsFalse(
JsonObjectFactory.JSONEquality(jaResult1, jaResult2),
"Merging of two arrays with overwriting enabled does work properly"
);
}
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 void RecursiveMergingJSONArraysWorksProperly()
{
JsonObject jo1 = new JsonObject();
JsonObject jo2 = new JsonObject();
JsonObject joResult1 = new JsonObject();
JsonObject joResult2;
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"
);
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"
);
}
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);
}
private void ConfigureJsonFactory <TJson>()
where TJson : class
{
JsonFactory.Setup(f => f.Create <TJson>())
.Returns(JsonObjectFactory.Get <TJson>().Object);
}
public void JSONEqualityMethodWorksProperly()
{
string JSON = "{\"boolean\":true,\"integer\":1,\"decimal\":1.2,\"string\":\"string\",\"object\":{\"property\":null},\"array\":[null,[2]]}";
// building a structure for comparison purposes
JsonObject jo = new JsonObject();
JsonObject joInner = new JsonObject();
JsonObject ja = new JsonObject(true);
JsonObject jaInner = new JsonObject(true);
jo.set("boolean", true);
jo.set("integer", 1);
jo.set("decimal", 1.2m);
jo.set("string", "string");
jo.set("object", joInner);
jo.set("array", ja);
joInner.setNull("property");
ja.setNull();
ja.set(jaInner);
jaInner.set(2);
Assert.IsTrue(
JsonObjectFactory.JSONEquality(JSON, JSON),
"JSONEquality method doesn't work correctly"
);
Assert.IsTrue(
JsonObjectFactory.JSONEquality(jo, jo),
"JSONEquality method doesn't work correctly"
);
Assert.IsTrue(
JsonObjectFactory.JSONEquality(jo, JSON),
"JSONEquality method doesn't work correctly"
);
JsonObject jo1 = new JsonObject();
JsonObject jo2 = new JsonObject();
JsonObject jo3 = new JsonObject();
jo1.set("a", "a");
jo1.set("b", "b");
jo1.set("c", "c");
jo2.set("d", "d");
jo2.set("e", "e");
jo2.set("f", "f");
jo3.set("a", "d");
jo3.set("b", "e");
jo3.set("c", "f");
Assert.IsFalse(
JsonObjectFactory.JSONEquality(jo1, jo2),
"JSONEquality method doesn't work correctly"
);
Assert.IsFalse(
JsonObjectFactory.JSONEquality(jo1, jo3),
"JSONEquality method doesn't work correctly"
);
Assert.IsFalse(
JsonObjectFactory.JSONEquality(jo2, jo3),
"JSONEquality method doesn't work correctly"
);
Assert.IsTrue(
JsonObjectFactory.JSONEquality(jo1, jo1),
"JSONEquality method doesn't work correctly"
);
Assert.IsTrue(
JsonObjectFactory.JSONEquality(jo2, jo2),
"JSONEquality method doesn't work correctly"
);
Assert.IsTrue(
JsonObjectFactory.JSONEquality(jo3, jo3),
"JSONEquality method doesn't work correctly"
);
}
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"
);
}
/// <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);
}
/// <summary>
/// Set any options for services that aren't generic
/// </summary>
private void setServiceOptions()
{
switch (this.service)
{
case "assess":
// fall-through
case "questions":
this.signRequestData = false;
if (this.service == "assess" && Tools.array_key_exists("questionsApiActivity", this.requestPacket))
{
JsonObject questionsApi = this.requestPacket.getJsonObject("questionsApiActivity");
if (questionsApi == null)
{
throw new Exception("requestPacket['questionsApiActivity'] is not an array");
}
string domain = "assess.learnosity.com";
if (Tools.array_key_exists("domain", this.securityPacket))
{
domain = this.securityPacket.getString("domain");
}
else if (Tools.array_key_exists("domain", questionsApi))
{
domain = questionsApi.getString("domain");
}
JsonObject questionsApiActivity = new JsonObject();
List <string> signatureList = new List <string>();
signatureList.Add(this.securityPacket.getString("consumer_key"));
signatureList.Add(domain);
signatureList.Add(this.securityPacket.getString("timestamp"));
if (Tools.array_key_exists("expires", this.securityPacket))
{
signatureList.Add(this.securityPacket.getString("expires"));
questionsApiActivity.set("expires", this.securityPacket.getString("expires"));
questionsApi.remove("expires");
}
signatureList.Add(this.securityPacket.getString("user_id"));
signatureList.Add(this.secret);
string signature = this.hashValue(signatureList.ToArray());
questionsApiActivity.set("consumer_key", this.securityPacket.getString("consumer_key"));
questionsApiActivity.set("timestamp", this.securityPacket.getString("timestamp"));
questionsApiActivity.set("user_id", this.securityPacket.getString("user_id"));
questionsApiActivity.set("signature", signature);
questionsApi.remove("domain");
questionsApi.remove("consumer_key");
questionsApi.remove("timestamp");
questionsApi.remove("user_id");
questionsApi.remove("signature");
questionsApiActivity = JsonObjectFactory.merge(questionsApiActivity, questionsApi);
this.requestPacket.set("questionsApiActivity", questionsApiActivity);
}
break;
case "items":
// fall-through
case "reports":
if (!Tools.array_key_exists("user_id", this.securityPacket) && Tools.array_key_exists("user_id", this.requestPacket))
{
this.securityPacket.set("user_id", this.requestPacket.getString("user_id"));
}
break;
case "events":
string consumer_key = this.securityPacket.getString("consumer_key");
JsonObject hashedUsers;
this.signRequestData = false;
JsonObject requestPackageUsers = this.requestPacket.getJsonObject("users");
if (requestPackageUsers != null)
{
string[] users = requestPackageUsers.getValuesArray();
if (users != null && users.Length > 0)
{
hashedUsers = new JsonObject();
for (int i = 0; i < users.Length; i++)
{
string user_id = users[i];
hashedUsers.set(user_id, Tools.hash(this.algorithm, user_id + this.secret));
}
this.requestPacket.set("users", hashedUsers);
}
}
break;
default:
// do nothing
break;
}
}
