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 override bool Validate(RuleValidation validator)
{
ValidationError error;
if (_message == null)
{
error = new ValidationError("Message cannot be null", 123);
validator.Errors.Add(error);
return(false);
}
else
{
RuleExpressionInfo result = RuleExpressionWalker.Validate(validator, _message, false);
if ((result == null) || (result.ExpressionType != typeof(string)))
{
error = new ValidationError("Message must return string result", 123);
validator.Errors.Add(error);
return(false);
}
}
return(validator.Errors.Count == 0);
}
public override bool Validate(RuleValidation validator)
{
ValidationError error;
if (_applicationID == null || _typeID == null || _ruleID == null || _ruleName == null || _result == null || _createDate == null || _referenceID == null)
{
error = new ValidationError("Rule Stat Parameters cannot be null", 123);
validator.Errors.Add(error);
return(false);
}
else
{
RuleExpressionInfo applicationIDResult = RuleExpressionWalker.Validate(validator, _applicationID, false);
RuleExpressionInfo typeIDResult = RuleExpressionWalker.Validate(validator, _typeID, false);
RuleExpressionInfo ruleIDResult = RuleExpressionWalker.Validate(validator, _ruleID, false);
RuleExpressionInfo ruleNameResult = RuleExpressionWalker.Validate(validator, _ruleName, false);
RuleExpressionInfo resultResult = RuleExpressionWalker.Validate(validator, _result, false);
RuleExpressionInfo createDateResult = RuleExpressionWalker.Validate(validator, _createDate, false);
RuleExpressionInfo referenceIDResult = RuleExpressionWalker.Validate(validator, _referenceID, false);
if ((applicationIDResult == null) || (applicationIDResult.ExpressionType != typeof(Guid)))
{
error = new ValidationError("application id must be Guid", 123);
validator.Errors.Add(error);
return(false);
}
if ((typeIDResult == null) || (typeIDResult.ExpressionType != typeof(Guid)))
{
error = new ValidationError("type id must be Guid", 123);
validator.Errors.Add(error);
return(false);
}
if ((ruleIDResult == null) || (ruleIDResult.ExpressionType != typeof(Guid)))
{
error = new ValidationError("rule id must be a guid", 123);
validator.Errors.Add(error);
return(false);
}
if ((ruleNameResult == null) || (ruleNameResult.ExpressionType != typeof(string)))
{
error = new ValidationError("rule name must be a string", 123);
validator.Errors.Add(error);
return(false);
}
if ((resultResult == null) || (resultResult.ExpressionType != typeof(bool)))
{
error = new ValidationError("result must be a true or false", 123);
validator.Errors.Add(error);
return(false);
}
if ((createDateResult == null) || (createDateResult.ExpressionType != typeof(DateTime)))
{
error = new ValidationError("create date must be a DateTime", 123);
return(false);
}
if ((referenceIDResult == null) || (referenceIDResult.ExpressionType != typeof(Guid)))
{
error = new ValidationError("reference id must be Guid", 123);
validator.Errors.Add(error);
return(false);
}
}
return(validator.Errors.Count == 0);
}
public RuleExpressionInfo ValidateExpression(RuleValidation validation, CodeExpression expression, bool isWritten)
{
RuleExpressionInfo result = RuleExpressionWalker.Validate(validation, expression, false);
return(result);
}
