public static RuleExpressionInfo Validate(RuleValidation validation, CodeExpression expression, bool isWritten) { if (validation == null) { throw new ArgumentNullException("validation"); } // See if we've visited this node before. // Always check if written = true RuleExpressionInfo resultExprInfo = null; if (!isWritten) { resultExprInfo = validation.ExpressionInfo(expression); } if (resultExprInfo == null) { // First time we've seen this node. RuleExpressionInternal ruleExpr = GetExpression(expression); if (ruleExpr == null) { string message = string.Format(CultureInfo.CurrentCulture, Messages.CodeExpressionNotHandled, expression.GetType().FullName); ValidationError error = new ValidationError(message, ErrorNumbers.Error_CodeExpressionNotHandled); error.UserData[RuleUserDataKeys.ErrorObject] = expression; if (validation.Errors == null) { string typeName = string.Empty; if ((validation.ThisType != null) && (validation.ThisType.Name != null)) { typeName = validation.ThisType.Name; } string exceptionMessage = string.Format( CultureInfo.CurrentCulture, Messages.ErrorsCollectionMissing, typeName); throw new InvalidOperationException(exceptionMessage); } else { validation.Errors.Add(error); } return(null); } resultExprInfo = validation.ValidateSubexpression(expression, ruleExpr, isWritten); } return(resultExprInfo); }
private void ValidateExpression(RuleValidation validation, CodeExpression expression, string propertyName) { ValidationError error; if (expression == null) { error = new ValidationError(propertyName + " cannot be null", 123); validation.Errors.Add(error); } else { RuleExpressionInfo result = ValidateExpression(validation, expression, false); if ((result == null) || (result.ExpressionType != typeof(bool))) { error = new ValidationError(propertyName + " must return boolean result", 123); validation.Errors.Add(error); } } }
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); }
/// <summary> /// we could also do here alot of custom things say if we wanted to try to resolve the problem by providing a default /// or whatever we have many options here... /// </summary> /// <param name="validation"></param> /// <param name="expression"></param> /// <param name="propertyName"></param> private void ValidateExpression(RuleValidation validation, CodeExpression expression, string propertyName) { ValidationError error; if (expression == null) { error = new ValidationError(propertyName + " cannot be null", 123); validation.Errors.Add(error); } // here would could make sure that the value is not null if we want //or perhaps we could verify that the result is a particular type, we have //lots of options here to do whatever granular custom validation that we want. else { //do not remove this line very important, will not execute w/o it RuleExpressionInfo result = ValidateExpression(validation, expression, false); //if (result == null) //{ // error = new ValidationError(propertyName + " cannot be null value ", 123); // validation.Errors.Add(error); //} } }
internal override bool Validate(RuleValidation validation) { bool success = false; if (exprStatement.Expression == null) { ValidationError error = new ValidationError(Messages.NullInvokeStatementExpression, ErrorNumbers.Error_ParameterNotSet); error.UserData[RuleUserDataKeys.ErrorObject] = exprStatement; validation.Errors.Add(error); } else if (exprStatement.Expression is CodeMethodInvokeExpression) { RuleExpressionInfo exprInfo = RuleExpressionWalker.Validate(validation, exprStatement.Expression, false); success = (exprInfo != null); } else { ValidationError error = new ValidationError(Messages.InvokeNotHandled, ErrorNumbers.Error_CodeExpressionNotHandled); error.UserData[RuleUserDataKeys.ErrorObject] = exprStatement; validation.Errors.Add(error); } return(success); }
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); }
internal override bool Validate(RuleValidation validation) { bool success = false; string message; RuleExpressionInfo lhsExprInfo = null; if (assignStatement.Left == null) { ValidationError error = new ValidationError(Messages.NullAssignLeft, ErrorNumbers.Error_LeftOperandMissing); error.UserData[RuleUserDataKeys.ErrorObject] = assignStatement; validation.Errors.Add(error); } else { lhsExprInfo = validation.ExpressionInfo(assignStatement.Left); if (lhsExprInfo == null) { lhsExprInfo = RuleExpressionWalker.Validate(validation, assignStatement.Left, true); } } RuleExpressionInfo rhsExprInfo = null; if (assignStatement.Right == null) { ValidationError error = new ValidationError(Messages.NullAssignRight, ErrorNumbers.Error_RightOperandMissing); error.UserData[RuleUserDataKeys.ErrorObject] = assignStatement; validation.Errors.Add(error); } else { rhsExprInfo = RuleExpressionWalker.Validate(validation, assignStatement.Right, false); } if (lhsExprInfo != null && rhsExprInfo != null) { Type expressionType = rhsExprInfo.ExpressionType; Type assignmentType = lhsExprInfo.ExpressionType; if (assignmentType == typeof(NullLiteral)) { // Can't assign to a null literal. ValidationError error = new ValidationError(Messages.NullAssignLeft, ErrorNumbers.Error_LeftOperandInvalidType); error.UserData[RuleUserDataKeys.ErrorObject] = assignStatement; validation.Errors.Add(error); success = false; } else if (assignmentType == expressionType) { // Easy case, they're both the same type. success = true; } else { // The types aren't the same, but it still might be a legal assignment. if (!RuleValidation.TypesAreAssignable(expressionType, assignmentType, assignStatement.Right, out ValidationError error)) { if (error == null) { message = string.Format(CultureInfo.CurrentCulture, Messages.AssignNotAllowed, RuleDecompiler.DecompileType(expressionType), RuleDecompiler.DecompileType(assignmentType)); error = new ValidationError(message, ErrorNumbers.Error_OperandTypesIncompatible); } error.UserData[RuleUserDataKeys.ErrorObject] = assignStatement; validation.Errors.Add(error); } else { success = true; } } } return(success); }