/* * 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); } }