/// <summary>
/// Actual implementation how to validate the specified object.
/// </summary>
/// <param name="contextParams">Additional context parameters.</param>
/// <param name="errors"><see cref="ValidationErrors"/> instance to add error messages to.</param>
/// <param name="validationContext">The object to validate.</param>
/// <returns><c>True</c> if validation was successful, <c>False</c> otherwise.</returns>
protected override bool ValidateGroup(IDictionary<string, object> contextParams, IValidationErrors errors, object validationContext)
{
ValidationErrors tmpErrors = new ValidationErrors();
bool valid = false;
foreach (IValidator validator in Validators)
{
bool tmpValid = validator.Validate(validationContext, contextParams, tmpErrors);
if (valid && tmpValid)
{
valid = false;
if (this.FastValidate)
{
break;
}
}
else if (tmpValid)
{
valid = true;
}
}
if (!valid)
{
errors.MergeErrors(tmpErrors);
}
return valid;
}
/// <summary>
/// Gets or sets a flag specifying whether this binding is valid.
/// </summary>
/// <value>
/// <c>true</c> if this binding evaluated without errors;
/// <c>false</c> otherwise.
/// </value>
public bool IsValid(IValidationErrors errors)
{
if (errors == null) return true;
IList errorList = errors.GetErrors(ALL_BINDINGERRORS_PROVIDER);
return (errorList == null) || (!errorList.Contains(this.ErrorMessage));
}
/// <summary>Constructor</summary>
/// <param name="errors">Validation errors</param>
public ValidationException(IValidationErrors errors)
: base(errors.ToExceptionMessage())
{
Checker.ArgumentIsNull(errors, "errors");
Errors = errors;
}
/// <summary>
/// 把錯誤訊息記錄到IValidationDictionary的物件裡面
/// </summary>
/// <param name="validationDictionary">儲存目前Validation結果的Dictionary</param>
/// <param name="propertyErrors">要記錄到ValidationDictionary裡面的錯誤訊息</param>
public static void AddValidationErrors(this IValidationDictionary validationDictionary, IValidationErrors propertyErrors)
{
foreach (var databaseValidationError in propertyErrors.Errors)
{
validationDictionary.AddError(databaseValidationError.PropertyName, databaseValidationError.PropertyExceptionMessage);
}
}
/// <summary>
/// Called when associated validator is invalid.
/// </summary>
/// <param name="validationContext">Validation context.</param>
/// <param name="contextParams">Additional context parameters.</param>
/// <param name="errors">Validation errors container.</param>
protected override void OnInvalid(object validationContext, IDictionary<string, object> contextParams, IValidationErrors errors)
{
ErrorMessage error = CreateErrorMessage(validationContext, contextParams);
foreach (string provider in this.providers)
{
errors.AddError(provider.Trim(), error);
}
}
protected void ConsumeErrors(IValidationErrors errors)
{
//ModelState.Clear();
foreach (IValidationError error in errors)
{
ConsumeError(error);
}
}
/// <summary>
/// Binds target object to source object.
/// </summary>
/// <param name="source">
/// The source object.
/// </param>
/// <param name="target">
/// The target object.
/// </param>
/// <param name="validationErrors">
/// Validation errors collection that type conversion errors should be added to.
/// </param>
/// <param name="variables">
/// Variables that should be used during expression evaluation.
/// </param>
public override void BindTargetToSource(object source, object target, IValidationErrors validationErrors, IDictionary<string, object> variables)
{
if (variables == null)
{
variables = new Dictionary<string, object>();
}
variables["source"] = source;
variables["target"] = target;
sourceExpression.GetValue(null, variables);
}
/// <summary>
/// Binds source object to target object.
/// </summary>
/// <param name="source">
/// The source object.
/// </param>
/// <param name="target">
/// The target object.
/// </param>
/// <param name="validationErrors">
/// Validation errors collection that type conversion errors should be added to.
/// </param>
/// <param name="variables">
/// Variables that should be used during expression evaluation.
/// </param>
public override void BindSourceToTarget(object source, object target, IValidationErrors validationErrors,
IDictionary variables)
{
if (variables == null)
{
variables = new Hashtable();
}
variables["source"] = source;
variables["target"] = target;
targetExpression.GetValue(null, variables);
}
/// <summary>
/// Marks this binding's state as invalid for this validationErrors collection.
/// Returns false if <paramref name="validationErrors"/> is null.
/// </summary>
/// <param name="validationErrors"></param>
/// <returns>false, if validationErrors is null</returns>
protected bool SetInvalid(IValidationErrors validationErrors)
{
if (validationErrors != null)
{
foreach (string provider in this.ErrorProviders)
{
validationErrors.AddError(provider, this.ErrorMessage);
}
return true;
}
return false;
}
/// <summary>
/// Actual implementation how to validate the specified object.
/// </summary>
/// <param name="validationContext">The object to validate.</param>
/// <param name="contextParams">Additional context parameters.</param>
/// <param name="errors"><see cref="ValidationErrors"/> instance to add error messages to.</param>
/// <returns><c>True</c> if validation was successful, <c>False</c> otherwise.</returns>
protected override bool ValidateGroup(IDictionary contextParams, IValidationErrors errors, object validationContext)
{
bool valid = true;
foreach (IValidator validator in this.Validators)
{
valid = validator.Validate(validationContext, contextParams, errors) && valid;
if (!valid && this.FastValidate)
{
break;
}
}
return valid;
}
/// <summary>
/// Executes the action.
/// </summary>
/// <param name="isValid">Whether associated validator is valid or not.</param>
/// <param name="validationContext">Validation context.</param>
/// <param name="contextParams">Additional context parameters.</param>
/// <param name="errors">Validation errors container.</param>
public virtual void Execute(bool isValid, object validationContext, IDictionary contextParams, IValidationErrors errors)
{
if (EvaluateWhen(validationContext, contextParams))
{
if (isValid)
{
OnValid(validationContext, contextParams, errors);
}
else
{
OnInvalid(validationContext, contextParams, errors);
}
}
}
/// <summary>
/// Binds source object to target object.
/// </summary>
/// <param name="source">
/// The source object.
/// </param>
/// <param name="target">
/// The target object.
/// </param>
/// <param name="validationErrors">
/// Validation errors collection that type conversion errors should be added to.
/// </param>
/// <param name="variables">
/// Variables that should be used during expression evaluation.
/// </param>
public override void BindSourceToTarget(object source, object target, IValidationErrors validationErrors, IDictionary<string, object> variables)
{
if (this.IsValid(validationErrors)
&& (this.Direction == BindingDirection.Bidirectional || this.Direction == BindingDirection.SourceToTarget))
{
try
{
DoBindSourceToTarget(source, target, variables);
}
catch (Exception)
{
if (!SetInvalid(validationErrors)) throw;
}
}
}
/// <summary>
/// Validates the specified object.
/// </summary>
/// <param name="contextParams">Additional context parameters.</param>
/// <param name="errors"><see cref="ValidationErrors"/> instance to add error messages to.</param>
/// <param name="validationContext">The object to validate.</param>
/// <returns><c>True</c> if validation was successful, <c>False</c> otherwise.</returns>
protected override bool ValidateGroup(IDictionary<string, object> contextParams, IValidationErrors errors, object validationContext)
{
// capture errors in separate collection to only add them to the error collector in case of errors
ValidationErrors tmpErrors = new ValidationErrors();
bool valid = false;
foreach (IValidator validator in Validators)
{
valid = validator.Validate(validationContext, contextParams, tmpErrors) || valid;
if (valid && FastValidate)
{
break;
}
}
if (!valid)
{
errors.MergeErrors(tmpErrors);
}
return valid;
}
/// <summary>
/// Called when associated validator is invalid.
/// </summary>
/// <param name="validationContext">Validation context.</param>
/// <param name="contextParams">Additional context parameters.</param>
/// <param name="errors">Validation errors container.</param>
protected override void OnInvalid(object validationContext, IDictionary<string, object> contextParams, IValidationErrors errors)
{
if (throwsExpression != null)
{
object o = null;
try
{
o = throwsExpression.GetValue(null, contextParams);
}
catch (Exception e)
{
log.Error("Was not able to evaluate action expression [" + throwsExpression + "]", e);
}
Exception exception = o as Exception;
if (exception != null)
{
throw exception;
}
}
throw new ValidationException(errors);
}
/// <summary>
/// Merges another instance of <see cref="ValidationErrors"/> into this one.
/// </summary>
/// <remarks>
/// <p>
/// If the supplied <paramref name="errorsToMerge"/> is <see lang="null"/>,
/// then no errors will be added to this instance, and this method will
/// (silently) return.
/// </p>
/// </remarks>
/// <param name="errorsToMerge">
/// The validation errors to merge; can be <see lang="null"/>.
/// </param>
public void MergeErrors(IValidationErrors errorsToMerge)
{
if (errorsToMerge != null)
{
foreach(string provider in errorsToMerge.Providers)
{
List<ErrorMessage> errList;
List<ErrorMessage> other = new List<ErrorMessage>(errorsToMerge.GetErrors(provider));
if (!errorMap.TryGetValue(provider, out errList))
{
this.errorMap[provider] = other;
}
else
{
errList.AddRange(other);
}
}
// foreach (DictionaryEntry errorEntry in errorsToMerge.errorMap)
// {
// ArrayList errList = (ArrayList) this.errorMap[errorEntry.Key];
// if (errList == null)
// {
// this.errorMap[errorEntry.Key] = errorEntry.Value;
// }
// else
// {
// errList.AddRange((IList) errorEntry.Value);
// }
// }
}
}
/// <summary> /// Binds target object to source object. /// </summary> /// <param name="source"> /// The source object. /// </param> /// <param name="target"> /// The target object. /// </param> /// <param name="validationErrors"> /// Validation errors collection that type conversion errors should be added to. /// </param> /// <param name="variables"> /// Variables that should be used during expression evaluation. /// </param> public abstract void BindTargetToSource(object source, object target, IValidationErrors validationErrors, IDictionary variables);
/// <summary> /// Actual implementation how to validate the specified object. /// </summary> /// <param name="validationContext">The object to validate.</param> /// <param name="contextParams">Additional context parameters.</param> /// <param name="errors"><see cref="ValidationErrors"/> instance to add error messages to.</param> /// <returns><c>True</c> if validation was successful, <c>False</c> otherwise.</returns> protected abstract bool ValidateGroup(IDictionary contextParams, IValidationErrors errors, object validationContext);
/// <summary>
/// Validates the specified object.
/// </summary>
/// <param name="validationContext">The object to validate.</param>
/// <param name="contextParams">Additional context parameters.</param>
/// <param name="errors"><see cref="ValidationErrors"/> instance to add error messages to.</param>
/// <returns><c>True</c> if validation was successful, <c>False</c> otherwise.</returns>
public bool Validate(object validationContext, IDictionary contextParams, IValidationErrors errors)
{
bool valid = true;
if (When == null ||
Convert.ToBoolean(When.GetValue(validationContext, contextParams)))
{
if (Context != null)
{
validationContext = Context.GetValue(validationContext, contextParams);
}
if (validator == null)
{
validator = (IValidator)objectFactory.GetObject(Name);
}
valid = validator.Validate(validationContext, contextParams, errors);
}
return valid;
}
/// <summary>
/// Binds target object to source object.
/// </summary>
/// <param name="source">
/// The source object.
/// </param>
/// <param name="target">
/// The target object.
/// </param>
/// <param name="validationErrors">
/// Validation errors collection that type conversion errors should be added to.
/// </param>
public virtual void BindTargetToSource(object source, object target, IValidationErrors validationErrors)
{
BindTargetToSource(source, target, validationErrors, null);
}
/// <summary>
/// Actual implementation how to validate the specified object.
/// </summary>
/// <param name="validationContext">The object to validate.</param>
/// <param name="contextParams">Additional context parameters.</param>
/// <param name="errors"><see cref="ValidationErrors"/> instance to add error messages to.</param>
/// <returns><c>True</c> if validation was successful, <c>False</c> otherwise.</returns>
protected override bool ValidateGroup(IDictionary contextParams, IValidationErrors errors, object validationContext)
{
bool valid = true;
IEnumerable collectionToValidate = (validationContext is IDictionary
? ((IDictionary) validationContext).Values
: (IEnumerable) validationContext);
// decide whether to pass new validation errors collection
//(and discard error messages returned by the item validators)
// OR to pass validation errors collection that was passed to this method
//(and collect all error messages returned by the item validators)
IValidationErrors err = (includeElementErrors)? errors : new ValidationErrors();
foreach (object objectToValidate in collectionToValidate)
{
foreach (IValidator validator in this.Validators)
{
valid = validator.Validate(objectToValidate, contextParams, err) && valid;
if (!valid && this.FastValidate)
{
break;
}
}
if (!valid && this.FastValidate)
{
break;
}
}
return valid;
}
/// <summary>
/// Validates the specified object.
/// </summary>
/// <param name="validationContext">The object to validate.</param>
/// <param name="errors"><see cref="ValidationErrors"/> instance to add error messages to.</param>
/// <returns><c>True</c> if validation was successful, <c>False</c> otherwise.</returns>
public bool Validate(object validationContext, IValidationErrors errors)
{
return Validate(validationContext, null, errors);
}
/// <summary>
/// Processes the error messages.
/// </summary>
/// <param name="isValid">Whether validator is valid or not.</param>
/// <param name="validationContext">Validation context.</param>
/// <param name="contextParams">Additional context parameters.</param>
/// <param name="errors">Validation errors container.</param>
protected void ProcessActions(bool isValid, object validationContext, IDictionary contextParams, IValidationErrors errors)
{
if (actions != null && actions.Count > 0)
{
foreach (IValidationAction action in actions)
{
action.Execute(isValid, validationContext, contextParams, errors);
}
}
}
/// <summary>
/// Validates the specified collection of objects.
/// If the <c>IncludeElementErrors</c> property was set to <c>true</c>,
/// <paramref name="errors"/> collection will contain a union of all validation error messages
/// for the contained validators;
/// Otherwise it will contain only error messages that were set for this Validator.
/// </summary>
/// <param name="validationContext">The collection to validate.</param>
/// <param name="contextParams">Additional context parameters.</param>
/// <param name="errors"><see cref="ValidationErrors"/> instance to add error messages to.</param>
/// <returns><c>True</c> if validation was successful, <c>False</c> otherwise.</returns>
public override bool Validate(object validationContext, IDictionary contextParams, IValidationErrors errors)
{
if (Context != null)
{
validationContext = Context.GetValue(validationContext, contextParams);
}
if (!(validationContext is IEnumerable))
{
throw new ArgumentException("The type of the object for validation must be subtype of IEnumerable.");
}
return base.Validate(validationContext, contextParams, errors);
}
/// <summary>
/// Validates the specified object.
/// </summary>
/// <param name="validationContext">The object to validate.</param>
/// <param name="contextParams">Additional context parameters.</param>
/// <param name="errors"><see cref="ValidationErrors"/> instance to add error messages to.</param>
/// <returns><c>True</c> if validation was successful, <c>False</c> otherwise.</returns>
public override bool Validate(object validationContext, IDictionary contextParams, IValidationErrors errors)
{
if (EvaluateWhen(validationContext, contextParams))
{
bool valid = ValidateGroup(contextParams, errors, validationContext);
ProcessActions(valid, validationContext, contextParams, errors);
return valid;
}
return true;
}
/// <summary> /// Validates the specified object. /// </summary> /// <param name="validationContext">The object to validate.</param> /// <param name="contextParams">Additional context parameters.</param> /// <param name="errors"><see cref="ValidationErrors"/> instance to add error messages to.</param> /// <returns><c>True</c> if validation was successful, <c>False</c> otherwise.</returns> public abstract bool Validate(object validationContext, IDictionary contextParams, IValidationErrors errors);
// CLOVER:OFF
/// <summary>
/// Called when associated validator is valid.
/// </summary>
/// <param name="validationContext">Validation context.</param>
/// <param name="contextParams">Additional context parameters.</param>
/// <param name="errors">Validation errors container.</param>
protected virtual void OnValid(object validationContext, IDictionary contextParams, IValidationErrors errors)
{
}
/// <summary>
/// Called when associated validator is valid.
/// </summary>
/// <param name="validationContext">Validation context.</param>
/// <param name="contextParams">Additional context parameters.</param>
/// <param name="errors">Validation errors container.</param>
protected override void OnValid(object validationContext, IDictionary contextParams, IValidationErrors errors)
{
if (Valid != null)
{
Valid.GetValue(validationContext, contextParams);
}
}
/// <summary>
/// Validates the specified object.
/// </summary>
/// <param name="validationContext">The object to validate.</param>
/// <param name="contextParams">Additional context parameters.</param>
/// <param name="errors"><see cref="ValidationErrors"/> instance to add error messages to.</param>
/// <returns><c>True</c> if validation was successful, <c>False</c> otherwise.</returns>
public override bool Validate(object validationContext, IDictionary<string, object> contextParams, IValidationErrors errors)
{
bool valid = true;
if (EvaluateWhen(validationContext, contextParams))
{
valid = Validate(EvaluateTest(validationContext, contextParams));
ProcessActions(valid, validationContext, contextParams, errors);
}
return valid;
}
private void WhenMultipleValidatorsReturnTrue(ExclusiveValidatorGroup vg, IValidationErrors errors)
{
vg.Actions.Add(new ErrorMessageAction("exclusiveError", "exclusiveErrors"));
vg.Validators.Add(new FalseValidator());
vg.Validators.Add(new TrueValidator());
vg.Validators.Add(new TrueValidator());
vg.Validators.Add(new FalseValidator());
errors.AddError("existingErrors", new ErrorMessage("error", null));
bool valid = vg.Validate(new object(), errors);
Assert.IsFalse(valid, "Validation should not succeed when multiple inner validators return true.");
Assert.AreEqual(1, errors.GetErrors("exclusiveErrors").Count);
Assert.AreEqual(1, errors.GetErrors("existingErrors").Count);
}
/// <summary>
/// Binds target object to source object.
/// </summary>
/// <param name="source">
/// The source object.
/// </param>
/// <param name="target">
/// The target object.
/// </param>
/// <param name="validationErrors">
/// Validation errors collection that type conversion errors should be added to.
/// </param>
/// <param name="variables">
/// Variables that should be used during expression evaluation.
/// </param>
public override void BindTargetToSource(object source, object target, IValidationErrors validationErrors,
IDictionary variables)
{
if (this.IsValid(validationErrors)
&& (this.Direction == BindingDirection.Bidirectional || this.Direction == BindingDirection.TargetToSource))
{
try
{
DoBindTargetToSource(source, target, variables);
}
catch (Exception ex)
{
log.Warn(string.Format("Failed binding[{0}]:{1}", this.Id, ex));
if (!SetInvalid(validationErrors)) throw;
}
}
}
