public RuleExpressionResult Evaluate(RuleExecution execution)
{
//StringComparer.CurrentCultureIgnoreCase;
RuleValidation rv = new RuleValidation(execution.ThisObject.GetType(), null);
ValidateExpression(rv, _containsMethodInvocationExpression, false);
RuleExpressionResult singleResult = Evaluate(execution, _containsMethodInvocationExpression);
if (rv.Errors.Count > 0)
{
ValidationErrorCollection errors = rv.Errors;
string validationErrorMessages = Helper.GetErrorMessageFromValidationErrorsCollection(errors);
throw new Exception(validationErrorMessages);
}
bool boolSingleResult = (bool)singleResult.Value;
if (boolSingleResult)
{
return(resultTrue);
}
else
{
return(resultFalse);
}
}
public override void Execute(RuleExecution context)
{
//we passed in at definition time what the code expressions for various properties are
//then they are evaluated so this.PropertyName for example would now be "the value of the property" if we passed
//in a CodePrimitiveExpression like "true" or "false" or "1" etc those values would now be here
RuleExpressionResult applicationIDResult = RuleExpressionWalker.Evaluate(context, _applicationID);
RuleExpressionResult typeIDResult = RuleExpressionWalker.Evaluate(context, _typeID);
RuleExpressionResult ruleIDResult = RuleExpressionWalker.Evaluate(context, _ruleID);
RuleExpressionResult ruleNameResult = RuleExpressionWalker.Evaluate(context, _ruleName);
RuleExpressionResult resultResult = RuleExpressionWalker.Evaluate(context, _result);
RuleExpressionResult createDateResult = RuleExpressionWalker.Evaluate(context, _createDate);
RuleExpressionResult referenceIDResult = RuleExpressionWalker.Evaluate(context, _referenceID);
//this is where the work is actually done
if (applicationIDResult != null && ruleIDResult != null && ruleNameResult != null && resultResult != null &&
createDateResult != null)
{
RuleStats ruleStats = new RuleStats();
ruleStats.Insert((Guid)applicationIDResult.Value, (Guid)typeIDResult.Value, (Guid)ruleIDResult.Value, (string)ruleNameResult.Value, (bool)resultResult.Value, (DateTime)createDateResult.Value,
(Guid)referenceIDResult.Value);
}
}
public RuleExpressionResult Evaluate(RuleExecution execution)
{
RuleValidation rv = new RuleValidation(execution.ThisObject.GetType(), null);
ValidateExpression(rv, _logicalAndExpression, false);
// start by doing the first 2 expressions
RuleExpressionResult singleResult = Evaluate(execution, _logicalAndExpression);
if (rv.Errors.Count > 0)
{
ValidationErrorCollection errors = rv.Errors;
string validationErrorMessages = Helper.GetErrorMessageFromValidationErrorsCollection(errors);
throw new Exception(validationErrorMessages);
}
// start by doing the first 2 expressions
bool boolSingleResult = (bool)singleResult.Value;
if (boolSingleResult)
{
// left and right true
return(resultTrue);
}
else
{
//either left or right or both are false
return(resultFalse);
}
}
public RuleExpressionResult Evaluate(RuleExecution execution)
{
RuleValidation rv = new RuleValidation(execution.ThisObject.GetType(), null);
ValidateExpression(rv, _singleExpression, false);
// start by doing the first 2 expressions
RuleExpressionResult singleResult = Evaluate(execution, _singleExpression);
if (rv.Errors.Count > 0)
{
ValidationErrorCollection errors = rv.Errors;
string validationErrorMessages = Helper.GetErrorMessageFromValidationErrorsCollection(errors);
throw new Exception(validationErrorMessages);
}
// start by doing the first 2 expressions
bool boolSingleResult = (bool)singleResult.Value;
bool negatedSingleResult = !boolSingleResult;
if (negatedSingleResult)
{
// return negated value
return(resultTrue);
}
else
{
//return negated value
return(resultFalse);
}
}
public RuleExpressionResult Evaluate(RuleExecution execution)
{
//StringComparer.CurrentCultureIgnoreCase;
RuleValidation rv = new RuleValidation(execution.ThisObject.GetType(), null);
ValidateExpression(rv, _binaryExpressionBasedOnComparisonType, false);
// start by doing the first 2 expressions
RuleExpressionResult singleResult = Evaluate(execution, _binaryExpressionBasedOnComparisonType);
if (rv.Errors.Count > 0)
{
ValidationErrorCollection errors = rv.Errors;
string validationErrorMessages = Helper.GetErrorMessageFromValidationErrorsCollection(errors);
throw new Exception(validationErrorMessages);
}
// start by doing the first 2 expressions
bool boolSingleResult = (bool)singleResult.Value;
if (boolSingleResult)
{
return(resultTrue);
}
else
{
return(resultFalse);
}
}
public override void Execute(RuleExecution context)
{
RuleExpressionResult result = RuleExpressionWalker.Evaluate(context, _message);
if (result != null)
{
Console.WriteLine(result.Value);
}
}
public void AddEvaluationResult(string ruleIdGuidString, string ruleName, RuleExpressionResult result)
{
if (_translatedRuleSet)
{
Guid ruleId = new Guid(ruleIdGuidString);
_evaluatedRules.Add(ruleId, result);
}
else
{
_nonTranslatedRulesEvaluatedRules.Add(ruleName, result);
}
}
private void EvaluateRule(Rule rule, ref MSRuleSetEvaluationResult ruleSetEvaluationResult, ref RuleValidation rv)
{
rv.Errors.Clear();
IRuleExpression ruleExpression = (IRuleExpression)((RuleExpressionCondition)rule.Condition).Expression;
RuleExecution re = new RuleExecution(rv, _instanceOfObject);
RuleExpressionInfo info = RuleExpressionWalker.Validate(rv, (CodeExpression)ruleExpression, true);
if (rv.Errors.Count > 0)
{
//string validationErrorMessages = Helper.GetErrorMessageFromValidationErrorsCollection(errors);
ruleSetEvaluationResult.AddValidationError(rule.Name, rule.Description, rv.Errors);
}
else
{
RuleExpressionResult result = RuleExpressionWalker.Evaluate(re, (CodeExpression)ruleExpression);
ruleSetEvaluationResult.AddEvaluationResult(rule.Name, rule.Description, result);
}
}
public DotNetNancy.Rules.RuleSet.RuleSetDefinition.Action[] GetThenActions(Guid guid, RuleExpressionResult ruleExpressionResult)
{
DotNetNancy.Rules.RuleSet.RuleSetDefinition.Action[] thenActions = null;
if (_translatedRuleSet)
{
thenActions = _ruleSetTranslationResult.GetThenActionsByRuleID(guid);
}
return(thenActions);
}
