/*
* Sample data need to be in the below format
* string changedParameter = "p_123"
* string jsonData = @"{'p_593':'G1C','p_1764':'78UK','p_706':5,'p_725':4,'p_335':'D(CARSZ)'}";
*/
public string ExecuteRule(string changedParameter, string formJSON)
{
var jsonDataObject = JObject.Parse(formJSON);
var parameters = this.apiData["data"]["parameters"];
var conditions = this.apiData["data"]["conditions"];
var rules = this.apiData["data"]["rules"];
var propertyValueGroup = this.apiData["data"]["propertyValueGroup"];
var parameter = parameters[changedParameter];
var rulesList = parameter["rules"].ToList();
for (int i = 0; i < rulesList.Count; i++)
{
var rule = rules[rulesList[i].ToString()];
var internalCondtion = rule["internalCondition"];
var selectionCondition = rule["selectionCondition"];
var internalConditionJSONLogic = conditions[internalCondtion.ToString()];
var selectionConditionJSONLogic = conditions[selectionCondition.ToString()];
// Create an evaluator with default operators.
var evaluator = new JsonLogicEvaluator(EvaluateOperators.Default);
// Apply the rule to the data.
object internalCondtionEvaluatorResult = evaluator.Apply(internalConditionJSONLogic, jsonDataObject);
object selectionCondtionEvaluatorResult = evaluator.Apply(selectionConditionJSONLogic, jsonDataObject);
if (internalCondtionEvaluatorResult.ToString() == "True" && selectionCondtionEvaluatorResult.ToString() == "True")
{
if (rule["action"].ToString() == "updateNLock")
{
var pvgId = rule["propertyValueGroup"];
var pvg = propertyValueGroup[pvgId.ToString()];
var pvgList = pvg.ToList();
for (int j = 0; j < pvgList.Count; j++)
{
var pvgData = pvgList[j];
foreach (JToken attribute in pvgData)
{
JProperty jProperty = attribute.ToObject <JProperty>();
string propertyName = jProperty.Name;
if (propertyName.Contains("p_"))
{
var parameterName = propertyName;
var parameterValue = pvgData[parameterName].ToList()[0];
jsonDataObject[parameterName] = parameterValue;
}
}
}
}
}
}
string output = Newtonsoft.Json.JsonConvert.SerializeObject(jsonDataObject);
return(output);
}
public void PassesJsonLogicTests()
{
// Arrange
var tests = JArray.Parse(System.IO.File.ReadAllText("tests.json"));
var evaluator = new JsonLogicEvaluator(EvaluateOperators.Default);
var results = tests.Where(t => t is JArray).Select(t => {
var test = t as JArray;
var rule = test[0];
object data = GetDataObject(test[1]);
var expectedResult = GetDataObject(test[2]);
object result = null;
try {
result = evaluator.Apply(rule, data);
Assert.Equal(expectedResult, result);
return(new TestDef(null, null, null));
} catch (Exception e) {
return(new TestDef(test, result, e));
}
});
// Act
var failures = results.Where(t => t.Test != null);
// Assert
Console.WriteLine("Failures:\n\t" + string.Join("\n\n\t", failures.Select(f => f.Test.ToString(Formatting.None) + " -> " + f.Expected.ToString())));
Assert.Empty(failures);
}
public void Apply(string argsJson, object expectedResult)
{
// Arrange
var rules = JsonFrom(argsJson);
var jsonLogic = new JsonLogicEvaluator(EvaluateOperators.Default);
// Act
var result = jsonLogic.Apply(rules, data);
// Assert
if (expectedResult is Array)
{
string[] expectedResultArr = (expectedResult as Array).Cast <object>().Select(i => i.ToString()).ToArray();
string[] resultArr;
if (result is Array)
{
resultArr = (result as Array).Cast <object>().Select(i => i.ToString()).ToArray();
}
else if (result is IEnumerable <object> )
{
resultArr = (result as IEnumerable <object>).Select(i => i.ToString()).ToArray();
}
else
{
throw new Exception("Cannot cast resultArr");
}
Assert.Equal(expectedResultArr, resultArr);
}
else
{
Assert.Equal(expectedResult, result);
}
}
public void GreaterThanLessThanWithMissingVar(string op, bool expectedResult)
{
var evaluator = new JsonLogicEvaluator(EvaluateOperators.Default);
var rule = JObject.Parse(@"{""" + op + @""": [{""var"": ""missingField""}, 1000]}");
var result = evaluator.Apply(rule, Data).IsTruthy();
Assert.Equal(expectedResult, result);
}
public void EqualityAndInequalityHandling(string ruleJson, object expectedResult)
{
var rule = JsonFrom(ruleJson);
var jsonLogic = new JsonLogicEvaluator(EvaluateOperators.Default);
_output.WriteLine($"{MethodBase.GetCurrentMethod().Name}() Testing {rule}");
// Act
var actualResult = jsonLogic.Apply(rule, Data);
Assert.Equal(expectedResult, actualResult);
}
public void VariableHandling(string ruleJson, string dataJson, object expectedResult)
{
var rule = JsonFrom(ruleJson);
var localData = JsonFrom(dataJson);
var jsonLogic = new JsonLogicEvaluator(EvaluateOperators.Default);
_output.WriteLine($"{MethodBase.GetCurrentMethod().Name}() Testing {rule} against {localData}");
// Act
var actualResult = jsonLogic.Apply(rule, localData);
Assert.Equal(expectedResult, actualResult);
}
public void Issue3_FilterBehaviorTest()
{
var localData = JsonConvert.DeserializeObject(@"[
{
`Prop1`: {
`PropA`: 5
},
`Prop2`: {
`PropB`: 18
}
},
{
`Prop1`: {
`PropA`: 1
},
`Prop2`: {
`PropB`: 35
}
}
]".Replace('`', '"'));
var rules = JObject.Parse(@"{
`filter`: [
{ `var`: `` },
{
`and`: [
{
`>=`: [
{ `var`: `Prop1.PropA` },
1
]
},
{
`>=`: [
{ `var`: `Prop2.PropB` },
19
]
}
]
}
]
}".Replace('`', '"'));
var evaluator = new JsonLogicEvaluator(EvaluateOperators.Default);
_output.WriteLine($"{MethodBase.GetCurrentMethod().Name}() Testing {rules} against {localData}");
// Act
var result = evaluator.Apply(rules, localData);
// Assert
Assert.Equal((result as object[]).Length, 1);
}
public void ConjunctExpression()
{
// Arrange
string dataJson = "{ `temp` : 100, `pie` : { `filling` : `apple` } }".Replace('`', '"');
string ruleJson = "{ `and` : [ {`<` : [ { `var` : `temp` }, 110 ]}, {`==` : [ { `var` : `pie.filling` }, `apple` ] }] }".Replace('`', '"');
var evaluator = new JsonLogicEvaluator(EvaluateOperators.Default);
// Act
var result = evaluator.Apply(JObject.Parse(ruleJson), JObject.Parse(dataJson));
// Assert
Assert.True((bool)result);
}
public void PassesJsonLogicDotComTests(string ruleJson, string dataJson, string expectedJson)
{
var rule = JsonFrom(ruleJson);
var data = GetDataObject(JsonFrom(dataJson));
var expected = GetDataObject(JsonFrom(expectedJson));
var evaluator = new JsonLogicEvaluator(EvaluateOperators.Default);
_output.WriteLine($"{MethodBase.GetCurrentMethod().Name}() Testing {rule} against {data}");
var result = evaluator.Apply(rule, data);
Assert.Equal(expected, result);
}
public void SimpleUseCase()
{
// Arrange
string jsonText = "{\">\": [{\"var\": \"MyNumber\"}, 3]}";
var rule = JObject.Parse(jsonText);
object data = new { MyNumber = 8 };
var evaluator = new JsonLogicEvaluator(EvaluateOperators.Default);
// Act
var result = evaluator.Apply(rule, data);
// Assert
Assert.True((bool)result);
}
public void Issue3_FilterBehaviorTest()
{
var data = JsonConvert.DeserializeObject(@"[
{
`Prop1`: {
`PropA`: 5
},
`Prop2`: {
`PropB`: 18
}
},
{
`Prop1`: {
`PropA`: 1
},
`Prop2`: {
`PropB`: 35
}
}
]".Replace('`', '"'));
var rules = JObject.Parse(@"{
`filter`: [
{ `var`: `` },
{
`and`: [
{
`>=`: [
{ `var`: `Prop1.PropA` },
1
]
},
{
`>=`: [
{ `var`: `Prop2.PropB` },
19
]
}
]
}
]
}".Replace('`', '"'));
var evaluator = new JsonLogicEvaluator(EvaluateOperators.Default);
// Act
var result = evaluator.Apply(rules, data);
// Assert
Assert.Equal((result as object[]).Length, 1);
}
public void ApplyWithNamingConventionConvertion(NamingConventionEnum ruleNamingConvention, NamingConventionEnum dataNamingConvention, string ruleJson,
object data, object expectedResult)
{
// Arrange
var rules = JsonFrom(ruleJson);
var jsonLogic = new JsonLogicEvaluator(EvaluateOperators.Default(ruleNamingConvention, dataNamingConvention));
_output.WriteLine($"{MethodBase.GetCurrentMethod().Name}() Testing {rules} against {data}");
// Act
var actualResult = jsonLogic.Apply(rules, data);
// Act & Assert
Assert.Equal(expectedResult, actualResult);
}
public void Issue2_Var_In_With_JObject()
{
// Arrange
string ruleJson = "{`in`:[{`var`:`marital_status`},[`Single`,`Married`,`Divorced`,`Widowed`,`Separated`]]}".Replace('`', '"');
string dataJson = "{`marital_status`: `Divorced`}".Replace('`', '"');
var rule = JObject.Parse(ruleJson);
var data = JObject.Parse(dataJson);
var evaluator = new JsonLogicEvaluator(EvaluateOperators.Default);
// Act
var result = evaluator.Apply(rule, data);
// Assert
Assert.True((bool)result);
}
public void SimpleUseCase()
{
// Arrange
string jsonText = "{\">\": [{\"var\": \"MyNumber\"}, 3]}";
var rule = JObject.Parse(jsonText);
object localData = new { MyNumber = 8 };
var evaluator = new JsonLogicEvaluator(EvaluateOperators.Default);
_output.WriteLine($"{MethodBase.GetCurrentMethod().Name}() Testing {rule} against {localData}");
// Act
var result = evaluator.Apply(rule, localData);
// Assert
Assert.True((bool)result);
}
public void ApplyThrowsException(string rulesJson, Type exceptionType)
{
// Arrange
var rules = JsonFrom(rulesJson);
var jsonLogic = new JsonLogicEvaluator(EvaluateOperators.Default);
object result = null;
// Act & Assert
try {
result = jsonLogic.Apply(rules, data);
} catch (Exception e) {
Assert.Equal(exceptionType, e.GetType());
} finally {
Assert.Null(result);
}
}
public void Issue2_Var_In_With_JObject()
{
// Arrange
string ruleJson = "{`in`:[{`var`:`marital_status`},[`Single`,`Married`,`Divorced`,`Widowed`,`Separated`]]}"
.Replace('`', '"');
string dataJson = "{`marital_status`: `Divorced`}".Replace('`', '"');
var rule = JObject.Parse(ruleJson);
var localData = JObject.Parse(dataJson);
var evaluator = new JsonLogicEvaluator(EvaluateOperators.Default);
_output.WriteLine($"{MethodBase.GetCurrentMethod().Name}() Testing {rule} against {localData}");
// Act
var result = evaluator.Apply(rule, localData);
// Assert
Assert.True((bool)result);
}
public void ConjunctExpression()
{
// Arrange
string dataJson = "{ `temp` : 100, `pie` : { `filling` : `apple` } }".Replace('`', '"');
string ruleJson =
"{ `and` : [ {`<` : [ { `var` : `temp` }, 110 ]}, {`==` : [ { `var` : `pie.filling` }, `apple` ] }] }"
.Replace('`', '"');
var evaluator = new JsonLogicEvaluator(EvaluateOperators.Default);
var rule = JObject.Parse(ruleJson);
var localData = JObject.Parse(dataJson);
_output.WriteLine($"{MethodBase.GetCurrentMethod().Name}() Testing {rule} against {localData}");
// Act
var result = evaluator.Apply(rule, localData);
// Assert
Assert.True((bool)result);
}
public void LocalHandling(string ruleJson, string dataJson, object expectedResult)
{
var rule = JsonFrom(ruleJson);
var localData = JsonFrom(dataJson);
var jsonLogic = new JsonLogicEvaluator(EvaluateOperators.Default);
_output.WriteLine($"{MethodBase.GetCurrentMethod().Name}() Testing {rule} against {localData}");
// Act
var actualResult = jsonLogic.Apply(rule, localData);
if (actualResult is JToken)
{
// use json comparison
expectedResult = expectedResult == null
? JValue.CreateNull()
: JsonFrom(expectedResult.ToString());
}
Assert.Equal(expectedResult, actualResult);
}
public void NestedFilterVariableAccess(string ruleJson, string dataJson, string expectedJson)
{
// Arrange
dataJson = dataJson.Replace('`', '"');
ruleJson = ruleJson.Replace('`', '"');
expectedJson = expectedJson.Replace('`', '"');
var evaluator = new JsonLogicEvaluator(EvaluateOperators.Default);
var rule = JsonFrom(ruleJson);
var localData = GetDataObject(JsonFrom(dataJson));
var expectedResult = GetDataObject(JsonFrom(expectedJson));
_output.WriteLine($"{MethodBase.GetCurrentMethod().Name}() Testing {rule} against {localData}");
// Act
var result = evaluator.Apply(rule, localData);
// Assert
Assert.Equal(expectedResult, result);
}
public void Apply(string argsJson, object expectedResult)
{
// Arrange
var rules = JsonFrom(argsJson);
var jsonLogic = new JsonLogicEvaluator(EvaluateOperators.Default);
_output.WriteLine($"{MethodBase.GetCurrentMethod().Name}() Testing {rules} against {Data}");
// Act
var result = jsonLogic.Apply(rules, Data);
// Assert
if (expectedResult is Array)
{
string[] expectedResultArr =
(expectedResult as Array).Cast <object>().Select(i => i.ToString()).ToArray();
string[] resultArr;
if (result is Array)
{
resultArr = (result as Array).Cast <object>().Select(i => i.ToString()).ToArray();
}
else if (result is IEnumerable <object> )
{
resultArr = (result as IEnumerable <object>).Select(i => i.ToString()).ToArray();
}
else
{
throw new Exception("Cannot cast resultArr");
}
Assert.Equal(expectedResultArr, resultArr);
}
else
{
Assert.Equal(expectedResult, result);
}
}
public void ApplyThrowsException(string rulesJson, Type exceptionType)
{
// Arrange
var rules = JsonFrom(rulesJson);
var jsonLogic = new JsonLogicEvaluator(EvaluateOperators.Default);
object result = null;
_output.WriteLine($"{MethodBase.GetCurrentMethod().Name}() Testing {rules} against {Data}");
// Act & Assert
try
{
result = jsonLogic.Apply(rules, Data);
}
catch (Exception e)
{
Assert.Equal(exceptionType, e.GetType());
}
finally
{
Assert.Null(result);
}
}