/// <summary>
/// Gets a list of fields that should be validated during the validation process.
/// </summary>
/// <param name="reason">The reason validation has been requested.</param>
/// <returns>An array of field names.</returns>
public override string[] GetFieldsToValidate(ValidationReason reason)
{
// Validate all fields in explicit validation; otherwise, only fields that have had focus
return reason == ValidationReason.ExplicitValidationRequested
? ValidationRequirements.Values.SelectMany(fields => fields.AsEnumerable()).Distinct().ToArray()
: ValidationRequirements.Where(kvp => _fieldsThatHaveHadFocus.Contains(kvp.Key)).SelectMany(kvp => kvp.Value).Distinct().ToArray();
}
public ValidationContext(object validationTarget, string[] fieldNamesToValidate, ValidationReason reason, Dispatcher dispatcher)
{
ValidationTarget = validationTarget;
FieldNamesToValidate = fieldNamesToValidate;
Reason = reason;
Dispatcher = dispatcher;
}
internal override void Validate(ValidationReason validationReason)
{
lock (this.thisLock)
{
this.CurrentState = this.CurrentState.Validate(validationReason);
}
}
private static string GetMessage(ValidationReason reason)
{
switch (reason)
{
case ValidationReason.UsernameIsUnavailable:
return(Constants.ValidationMessages.USERNAME_IS_UNAVAILABLE);
case ValidationReason.EmailIsUnavailable:
return(Constants.ValidationMessages.EMAIL_IS_UNAVAILABLE);
case ValidationReason.PasswordIsIncorrect:
return(Constants.ValidationMessages.PASSWORD_IS_INCORRECT);
case ValidationReason.FieldIsRequired:
return(Constants.ValidationMessages.FIELD_IS_REQUIRED);
case ValidationReason.UsernameIsIncorrectFormat:
return(Constants.ValidationMessages.USERNAME_IS_INCORRECT_FORMAT);
case ValidationReason.EmailIsIncorrectFormat:
return(Constants.ValidationMessages.EMAIL_IS_INCORRECT_FORMAT);
case ValidationReason.PasswordIsTooWeak:
return(Constants.ValidationMessages.PASSWORD_IS_TOO_WEAK);
case ValidationReason.ComparisonDoesNotMatch:
return(Constants.ValidationMessages.COMPARISON_DOES_NOT_MATCH);
case ValidationReason.InvalidValue:
return(Constants.ValidationMessages.INVALID_VALUE);
default:
return(Constants.ValidationMessages.INVALID_OPERATION);
}
}
/// <summary>
/// Records the fact that validation has taken place.
/// </summary>
/// <param name="reason">The reason.</param>
public override void RecordValidation(ValidationReason reason)
{
base.RecordValidation(reason);
if (reason == ValidationReason.ExplicitValidationRequested)
{
_manualValidationPerformed = true;
}
}
/// <summary>
/// Gets a list of fields that should be validated during the validation process.
/// </summary>
/// <param name="reason">The reason validation has been requested.</param>
/// <returns>An array of field names.</returns>
public override string[] GetFieldsToValidate(ValidationReason reason)
{
var results = new string[0];
if (reason == ValidationReason.ExplicitValidationRequested)
{
results = ValidationRequirements.Values.SelectMany(fields => fields.AsEnumerable()).Distinct().ToArray();
}
return results;
}
public ErrorsMarkedEventArgs(ICollection<ValidationError> errors,
ValidationReason reason,
ModelTreeManager modelTreeManager,
EditingContext context)
{
this.errors = errors;
this.reason = reason;
this.modelTreeManager = modelTreeManager;
this.context = context;
}
public ErrorsMarkedEventArgs(ICollection <ValidationError> errors,
ValidationReason reason,
ModelTreeManager modelTreeManager,
EditingContext context)
{
this.errors = errors;
this.reason = reason;
this.modelTreeManager = modelTreeManager;
this.context = context;
}
/// <summary>
/// Records the fact that validation has taken place.
/// </summary>
/// <param name="reason">The reason.</param>
public override void RecordValidation(ValidationReason reason)
{
base.RecordValidation(reason);
// After validation has taken place explicitly, treat every field as if it has had focus, as they should all
// be validated from this point on.
if (reason == ValidationReason.ExplicitValidationRequested)
{
_fieldsThatHaveHadFocus.AddRange(ValidationRequirements.Keys);
}
}
private bool HandleErrorsMarked(ICollection <ValidationError> errors, ValidationReason reason)
{
if (this.ErrorsMarked != null)
{
ErrorsMarkedEventArgs arg = new ErrorsMarkedEventArgs(errors, reason, this.modelTreeManager, this.context);
this.ErrorsMarked(this, arg);
return(arg.Handled);
}
return(false);
}
internal void ValidateWorkflow(ValidationReason reason)
{
if (this.isValidationDisabled)
{
return;
}
this.validationTaskDispatcher.DispatchWorkOnUIThread(DispatcherPriority.ApplicationIdle, new Action(() =>
{
this.ValidationSynchronizer.Validate(reason);
}));
}
public override void Validate(ValidationReason reason)
{
var errors = ValidateAndGetErrors(reason);
if (errors.Count > 0)
{
throw new ValidationFailedException(GetErrorMessage(reason))
{
ValidationErrors = errors
}
}
;
}
private string GetErrorMessage(ValidationReason reason)
{
switch (reason)
{
case ValidationReason.UserRequest:
return(Strings.ExValidationFailed);
case ValidationReason.Commit:
return(Strings.ExCanNotCommitATransactionEntitiesValidationFailed);
default:
throw new ArgumentOutOfRangeException("reason");
}
}
private void CancellableValidate(object state)
{
Fx.Assert(state is ValidationReason, "unusedState should always be a ValidationReason.");
ValidationReason reason = (ValidationReason)state;
try
{
Fx.Assert(this.cancellationTokenSource != null, "this.cancellationTokenSource should be constructed");
TValidationResult result = this.validationWork(reason, this.cancellationTokenSource.Token);
this.ValidationCompleted(result);
}
catch (OperationCanceledException)
{
this.ValidationCancelled();
}
}
public void Add <T>(string field, T value, ValidationReason reason)
{
if (typeof(T) == typeof(string) || typeof(T) == typeof(int) || typeof(T) == typeof(bool) ||
typeof(T) == typeof(long) || typeof(T) == typeof(double) || typeof(T) == typeof(decimal))
{
_reason.Add(new Tuple <string, object, ValidationReason>(field, value, reason));
}
else
{
if (value != null)
{
EntityValue = value;
PropertyInfo info = EntityValue.GetType().GetProperties().SingleOrDefault(o => string.Compare(o.Name, field, true) == 0);
if (info != null)
{
_reason.Add(new Tuple <string, object, ValidationReason>(field, info.GetValue(EntityValue), reason));
}
}
}
}
private string MapReasonToMessage(ValidationReason r)
{
switch (r)
{
case ValidationReason.Required:
return("Required field");
case ValidationReason.EmailFormat:
return("Invalid email format");
case ValidationReason.PhoneNumber:
return("Invalid mobile/landline number");
case ValidationReason.PinCode:
return("Invalid Pincode");
default:
return("General");
}
}
// Mark all the errors including their parent chains
private bool MarkErrors(ICollection <ValidationError> errors, ValidationReason reason, Activity rootActivity)
{
// Clear the previous errors/warnings and update the visuals
ClearErrors();
Fx.Assert(this.modelTreeManager != null, "ModelTreeManager is null."); // ModelTreeManager should not be null
if (this.HandleErrorsMarked(errors, reason))
{
return(false);
}
// Iterate through the new violation list and mark errors/warnings
foreach (ValidationError error in errors)
{
if (error.Source != null)
{
List <object> errorSourcePath = this.GetValidationErrorSourcePath(error.Source, error.SourceDetail);
MarkError(error, errorSourcePath);
}
else if (error.SourceDetail != null && error.SourceDetail is Receive)
{
// special-case:
// WorkflowService.Validate() may produce ValidationError { isWarning = true, Source = null, SourceDetail = Receive activity }
List <object> errorSourcePath = this.GetValidationErrorSourcePath((Activity)error.SourceDetail, null);
MarkError(error, errorSourcePath);
}
else if (rootActivity != null)
{
List <object> errorSourcePath = this.GetValidationErrorSourcePath(rootActivity, error.SourceDetail);
MarkError(error, errorSourcePath);
}
}
return(true);
}
public ValidationResult Validate(IFieldEventInformation info, ValidationReason validationReason, Boolean silent)
{
return default(ValidationResult);
}
/// <summary>
/// Gets a list of fields that should be validated during the validation process.
/// </summary>
/// <param name="reason">The reason validation has been requested.</param>
/// <returns>An array of field names.</returns>
public override string[] GetFieldsToValidate(ValidationReason reason)
{
return ValidationRequirements.Values.SelectMany(fields => fields.AsEnumerable()).Distinct().ToArray();
}
public override void Validate(ValidationReason reason)
{
}
internal abstract void Validate(ValidationReason reason);
/// <summary>
/// Returns a value indicating whether or not validation should be performed at this point.
/// </summary>
/// <param name="reason">The reason validation has been requested.</param>
/// <returns>
/// True if validation should proceed, otherwise false.
/// </returns>
public override bool ShouldValidate(ValidationReason reason)
{
return base.ShouldValidate(reason) || (_manualValidationPerformed && !LastValidationResultIsStillRelevant);
}
public ValidateRequestEventArgs(ValidationReason reason)
{
ValidationReason = reason;
}
/// <summary>
/// Returns a value indicating whether or not validation should be performed at this point.
/// </summary>
/// <param name="reason">The reason validation has been requested.</param>
/// <returns>
/// True if validation should proceed, otherwise false.
/// </returns>
public override bool ShouldValidate(ValidationReason reason)
{
// Always validate on explicit validation
return reason == ValidationReason.ExplicitValidationRequested ||
(!LastValidationResultIsStillRelevant);
}
public abstract void Validate(ValidationReason reason);
private void OnValidationWorkCompleted(Tuple <ValidationReason, ValidationResults, Exception> input)
{
ValidationReason reason = input.Item1;
ValidationResults results = input.Item2;
Exception exception = input.Item3;
Fx.Assert(results != null ^ exception != null, "result and exception should not both be null");
bool needsToMarkValidationErrors = false;
ValidationErrorInfo validationErrorInfo = null;
if (exception != null)
{
ModelItem rootModelItem = this.modelService.Root;
Activity rootActivity = rootModelItem.GetRootActivity();
if (rootActivity != null)
{
// We don't want any crash propagating from here as it causes VS to crash.
if (!this.ValidationErrors.ContainsKey(rootActivity))
{
ValidationErrorState validationError = new ValidationErrorState(new List <string>(), ValidationState.Error);
this.ValidationErrors.Add(rootActivity, validationError);
}
else
{
this.ValidationErrors[rootActivity].ValidationState = ValidationState.Error;
}
this.ValidationErrors[rootActivity].ErrorMessages.Add(exception.ToString());
// Notify an update to the attached properties
this.NotifyValidationPropertiesChanged(rootModelItem);
}
validationErrorInfo = new ValidationErrorInfo(exception.ToString());
needsToMarkValidationErrors = true;
}
DesignerPerfEventProvider perfProvider = this.context.Services.GetService <DesignerPerfEventProvider>();
perfProvider.WorkflowDesignerValidationStart();
List <ValidationError> validationErrors = null;
if (results != null)
{
validationErrors = new List <ValidationError>(results.Errors);
validationErrors.AddRange(results.Warnings);
Activity rootActivity = this.modelService.Root.GetRootActivity();
needsToMarkValidationErrors = this.MarkErrors(validationErrors, reason, rootActivity);
}
if (this.errorService != null && needsToMarkValidationErrors) // Error service could be null if no implementation has been provided
{
List <ValidationErrorInfo> errors = new List <ValidationErrorInfo>();
if (validationErrors != null)
{
foreach (ValidationError validationError in validationErrors)
{
Activity currentActivity = validationError.Source;
ValidationErrorInfo error = new ValidationErrorInfo(validationError);
// The acquired activity reference will be release in the Main AppDomain when it clear the error list
if (validationError.SourceDetail != null)
{
error.SourceReferenceId = this.objectReferenceService.AcquireObjectReference(validationError.SourceDetail);
}
else if (validationError.Source != null)
{
error.SourceReferenceId = this.objectReferenceService.AcquireObjectReference(validationError.Source);
}
else
{
error.SourceReferenceId = Guid.Empty;
}
errors.Add(error);
}
}
if (validationErrorInfo != null)
{
errors.Add(validationErrorInfo);
}
foreach (Guid acquiredObjectReference in this.AcquiredObjectReferences)
{
this.objectReferenceService.ReleaseObjectReference(acquiredObjectReference);
}
this.AcquiredObjectReferences.Clear();
foreach (ValidationErrorInfo error in errors)
{
if (error.SourceReferenceId != Guid.Empty)
{
this.AcquiredObjectReferences.Add(error.SourceReferenceId);
}
}
this.errorService.ShowValidationErrors(errors);
}
perfProvider.WorkflowDesignerValidationEnd();
this.OnValidationCompleted();
}
internal void ValidateWorkflow(ValidationReason reason)
{
if (this.isValidationDisabled)
{
return;
}
this.validationTaskDispatcher.DispatchWorkOnUIThread(DispatcherPriority.ApplicationIdle, new Action(() =>
{
this.ValidationSynchronizer.Validate(reason);
}));
}
public ValidationException(string message, ValidationReason reason) : base(message)
{
Reason = reason;
}
/// <summary>
/// Returns a value indicating whether or not validation should be performed at this point.
/// </summary>
/// <param name="reason">The reason validation has been requested.</param>
/// <returns>
/// True if validation should proceed, otherwise false.
/// </returns>
public override bool ShouldValidate(ValidationReason reason)
{
return reason == ValidationReason.ExplicitValidationRequested;
}
internal Tuple<ValidationReason, ValidationResults, Exception> CoreValidationWork(ValidationReason reason, CancellationToken cancellationToken)
{
this.settings.CancellationToken = cancellationToken;
ValidationResults results = null;
Exception exception = null;
try
{
ValidationRoot rootElement = this.GetRootElement();
if (rootElement != null)
{
results = rootElement.Validate(this.Settings);
}
}
catch (Exception e)
{
if (Fx.IsFatal(e) || e is OperationCanceledException)
{
throw;
}
exception = e;
}
return Tuple.Create(reason, results, exception);
}
private bool HandleErrorsMarked(ICollection<ValidationError> errors, ValidationReason reason)
{
if (this.ErrorsMarked != null)
{
ErrorsMarkedEventArgs arg = new ErrorsMarkedEventArgs(errors, reason, this.modelTreeManager, this.context);
this.ErrorsMarked(this, arg);
return arg.Handled;
}
return false;
}
// Mark all the errors including their parent chains
private bool MarkErrors(ICollection<ValidationError> errors, ValidationReason reason, Activity rootActivity)
{
// Clear the previous errors/warnings and update the visuals
ClearErrors();
Fx.Assert(this.modelTreeManager != null, "ModelTreeManager is null."); // ModelTreeManager should not be null
if (this.HandleErrorsMarked(errors, reason))
{
return false;
}
// Iterate through the new violation list and mark errors/warnings
foreach (ValidationError error in errors)
{
if (error.Source != null)
{
List<object> errorSourcePath = this.GetValidationErrorSourcePath(error.Source, error.SourceDetail);
MarkError(error, errorSourcePath);
}
else if (error.SourceDetail != null && error.SourceDetail is Receive)
{
// special-case:
// WorkflowService.Validate() may produce ValidationError { isWarning = true, Source = null, SourceDetail = Receive activity }
List<object> errorSourcePath = this.GetValidationErrorSourcePath((Activity)error.SourceDetail, null);
MarkError(error, errorSourcePath);
}
else if (rootActivity != null)
{
List<object> errorSourcePath = this.GetValidationErrorSourcePath(rootActivity, error.SourceDetail);
MarkError(error, errorSourcePath);
}
}
return true;
}
internal override void Validate(ValidationReason reason)
{
this.updateWork(this.validationWork(reason, /* cancellationToken = */ CancellationToken.None));
}
/// <summary>
/// Records the fact that validation has taken place.
/// </summary>
/// <param name="reason">The reason.</param>
public virtual void RecordValidation(ValidationReason reason)
{
LastValidationResultIsStillRelevant = true;
}
public override SynchronizerState Validate(ValidationReason reason)
{
this.Parent.ValidationWork(reason);
return(this.Parent.Validating);
}
/// <summary> /// Returns a value indicating whether or not validation should be performed at this point. /// </summary> /// <param name="reason">The reason validation has been requested.</param> /// <returns>True if validation should proceed, otherwise false.</returns> public abstract bool ShouldValidate(ValidationReason reason);
public override SynchronizerState Validate(ValidationReason reason)
{
this.Parent.lastValidationReason = reason;
return(this.Parent.CancellingForNextValidation);
}
public ValidationException(ValidationReason reason) : base(GetMessage(reason))
{
Reason = reason;
}
public override SynchronizerState Validate(ValidationReason reason)
{
// Validation need to give way to commit so that we have a responsive UI.
return(this.Parent.CancellingForDeactivation);
}
internal Tuple <ValidationReason, ValidationResults, Exception> CoreValidationWork(ValidationReason reason, CancellationToken cancellationToken)
{
this.settings.CancellationToken = cancellationToken;
ValidationResults results = null;
Exception exception = null;
try
{
ValidationRoot rootElement = this.GetRootElement();
if (rootElement != null)
{
results = rootElement.Validate(this.Settings);
}
}
catch (Exception e)
{
if (Fx.IsFatal(e) || e is OperationCanceledException)
{
throw;
}
exception = e;
}
return(Tuple.Create(reason, results, exception));
}
public override SynchronizerState Validate(ValidationReason reason)
{
// no-op - because commit will trigger validation anyway.
return(this.Parent.ValidationDeactivated);
}
private void ValidationWork(ValidationReason reason)
{
this.cancellationTokenSource = new CancellationTokenSource();
this.dispatcher.DispatchWorkOnBackgroundThread(Fx.ThunkCallback(new WaitCallback(this.CancellableValidate)), reason);
}
/// <summary>
/// Returns a value indicating whether or not validation should be performed at this point.
/// </summary>
/// <param name="reason">The reason validation has been requested.</param>
/// <returns>
/// True if validation should proceed, otherwise false.
/// </returns>
public override bool ShouldValidate(ValidationReason reason)
{
return reason == ValidationReason.ExplicitValidationRequested || !LastValidationResultIsStillRelevant;
}
public abstract SynchronizerState Validate(ValidationReason reason);
/// <summary> /// Gets a list of fields that should be validated during the validation process. /// </summary> /// <param name="reason">The reason validation has been requested.</param> /// <returns>An array of field names.</returns> public abstract string[] GetFieldsToValidate(ValidationReason reason);
