private bool ValidateProperty <T>(string propertyName, T value)
{
var validationResults = new List <ValidationResult>();
ValidationContext validationContext = new(this)
{
MemberName = propertyName
};
var success = Validator.TryValidateProperty(value, validationContext, validationResults);
if (!success)
{
_validationErrors[propertyName] = validationResults.Select(c => c.ErrorMessage).ToList();
}
else
{
_ = _validationErrors.Remove(propertyName);
}
ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(propertyName));
return(success);
}
}
public bool ValidateData()
{
HasErrors = (CurrentItem != null && (string.IsNullOrEmpty(CurrentItem.FirstName) || string.IsNullOrEmpty(CurrentItem.LastName)));
if (HasErrors)
{
if (string.IsNullOrEmpty(CurrentItem.FirstName))
{
ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs("FirstName"));
}
if (string.IsNullOrEmpty(CurrentItem.LastName))
{
ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs("LastName"));
}
}
else
{
return(true);
}
return(false);
}
public void AddError(
string propertyError,
Type ruleErrorType,
[CallerMemberName] string propertyName = "",
bool addUnique = false)
{
if (propertyError == null)
{
return;
}
if (!_ErrorsTypes.ContainsKey(propertyName))
{
_ErrorsTypes.Add(propertyName, new Dictionary <string, Type> {
{ propertyError, ruleErrorType }
});
}
else
if (!_ErrorsTypes[propertyName].ContainsKey(propertyError))
{
_ErrorsTypes[propertyName].Add(propertyError, ruleErrorType);
}
if (!_Errors.ContainsKey(propertyName))
{
_Errors.Add(propertyName, new List <string> {
propertyError
});
}
else
{
if (!addUnique || !_Errors[propertyName].Contains(propertyError))
{
_Errors[propertyName].Add(propertyError);
}
}
if (NotifyErrorsChangedEnabled)
{
ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(propertyName));
}
NotifyPropertyChanged(nameof(IsValid));
}
protected internal bool AddError(string errorMessage, [CallerMemberName] string propertyName = null)
{
var ph = HasErrors;
propertyName = propertyName ?? string.Empty;
if (!Errors.TryGetValue(propertyName, out var l))
{
Errors[propertyName] = l = new HashSet <string>();
}
if (l.Add(errorMessage))
{
ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(propertyName));
if (!ph)
{
RaisePropertyChanged(nameof(HasErrors));
}
return(true);
}
return(false);
}
protected void Validate(Func <bool> rule, string error, [CallerMemberName] string propertyName = "")
{
if (string.IsNullOrWhiteSpace(propertyName))
{
return;
}
if (_errors.ContainsKey(propertyName))
{
_errors.Remove(propertyName);
}
if (rule() == false)
{
_errors.Add(propertyName, new List <string> {
error
});
}
OnPropertyChanged(nameof(HasErrors));
ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(propertyName));
}
private void Validate(string propertyName)
{
var value = GetType().GetProperty(propertyName).GetValue(this);
var context = new ValidationContext(this)
{
MemberName = propertyName
};
var errors = new List <ValidationResult>();
validationErrors.Remove(propertyName);
if (Validator.TryValidateProperty(value, context, errors) == false)
{
validationErrors.Add(
propertyName,
errors.Select(e => e.ErrorMessage).ToList().AsReadOnly()
);
}
ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(propertyName));
OnPropertyChanged(nameof(HasErrors), false);
OnPropertyChanged(nameof(HasNoErrors), false);
}
public bool Validate([CallerMemberName] string propertyName = null)
{
if (!validators.ContainsKey(propertyName))
{
return(true);
}
_explicitlyCalled = true;
try
{
if (validators[propertyName].Any(attribute => !attribute.IsValid(this.propertyGetters[propertyName](this))))
{
ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(propertyName));
return(false);
}
return(true);
}
finally
{
_explicitlyCalled = false;
}
}
public void Validate <T>(string propertyName, T propertyValue, IValidator <T> validator)
{
var propertyErrors = GetErrors(propertyName) as List <string>;
if (propertyErrors == null)
{
propertyErrors = new List <string>();
}
else
{
propertyErrors.Clear();
}
if (validator.Validate(propertyValue) == false)
{
propertyErrors.AddRange(validator.ValidationErrorMessages);
}
ErrorsDictionary[propertyName] = propertyErrors;
ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(propertyName));
}
public void MergeErrors(IEnumerable <ValidationFailure> validationFailures)
{
var newInvalidProperties = validationFailures.Select(e => e.PropertyName).ToList();
var oldInvalidProperties = _modelErrors.Keys.ToList();
var validProperties = oldInvalidProperties.Except(newInvalidProperties);
foreach (var validProperty in validProperties)
{
_modelErrors[validProperty].Clear();
ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(validProperty));
}
foreach (var invalidProperty in newInvalidProperties)
{
var failures = validationFailures.Where(e => e.PropertyName.Equals(invalidProperty)).ToList();
foreach (var failure in failures)
{
var errorMessage = failure.ErrorMessage;
_modelErrors.AddOrUpdate(invalidProperty, new List <string>()
{
errorMessage
}, (key, messages) =>
{
if (!messages.Contains(errorMessage))
{
messages.Add(errorMessage);
}
return(messages);
});
}
ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(invalidProperty));
}
}
private void SetError(string propertyName, Tuple <string, bool> incoming)
{
bool signal = false;
if (incoming == null)
{
signal = this.errors.Remove(propertyName);
}
else
{
if (signal = !this.errors.TryGetValue(propertyName, out Tuple <string, bool> current) || !Equals(current, incoming))
{
this.errors[propertyName] = incoming;
}
}
if (signal)
{
OnPropertyChanged(nameof(HasErrors));
ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(propertyName));
((RelayCommand)CreateResourceCommand).ChangeCanExecute();
}
}
protected internal bool RemoveError(string errorMessage, [CallerMemberName] string propertyName = null)
{
var ph = HasErrors;
propertyName = propertyName ?? string.Empty;
if (_Errors != null &&
_Errors.TryGetValue(propertyName, out var l) &&
l.Remove(errorMessage))
{
if (!l.Any())
{
_Errors.Remove(propertyName);
}
ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(propertyName));
if (ph && !HasErrors)
{
RaisePropertyChanged(nameof(HasErrors));
}
return(true);
}
return(false);
}
private void ValidateProperty <T>(T value, [CallerMemberName] string propertyName = null)
{
if (propertyName == null)
{
return;
}
var issues = new List <Validation>();
var validationContext = new ValidationContext(this);
validationContext.MemberName = propertyName;
var validationResult = new Collection <ValidationResult>();
if (!Validator.TryValidateProperty(value, validationContext, validationResult))
{
issues.AddRange(validationResult.Select(result => Validation.Error(result.ErrorMessage)));
}
if (_validationRules.TryGetValue(propertyName, out var validationRules))
{
issues.AddRange(validationRules
.Cast <Func <T, Validation> >()
.Select(validationRule => validationRule(value))
.Where(validationIssue => validationIssue != null));
}
_validationIssues.Remove(propertyName);
ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(propertyName));
if (issues.Any())
{
_validationIssues[propertyName] = issues;
}
ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(propertyName));
}
public bool TryValidateModel()
{
ValidationContext context = new ValidationContext(this);
validationResults.Clear();
validationErrors.Clear();
if (!Validator.TryValidateObject(this, context, validationResults, true))
{
foreach (ValidationResult validationResult in validationResults)
{
string property = validationResult.MemberNames.ElementAt(0);
if (validationErrors.ContainsKey(property))
{
validationErrors[property].Add(validationResult.ErrorMessage);
}
else
{
validationErrors.Add(property, new List <string> {
validationResult.ErrorMessage
});
}
}
foreach (var property in GetValidatableProperties())
{
ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(property));
}
return(false);
}
foreach (var property in GetValidatableProperties())
{
ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(property));
}
return(true);
}
public async void ValidateProperty <T>(string propertyName, T value)
{
var results = new List <ValidationResult>();
ValidationContext context = new ValidationContext(this);
context.MemberName = propertyName;
Validator.TryValidateProperty(value, context, results);
List <string> bussinessErrors = null;
if (ValidationDelegate != null)
{
bussinessErrors = await ValidationDelegate(this, propertyName);
}
if (bussinessErrors != null)
{
if (_errors.ContainsKey(propertyName))
{
_errors[propertyName].AddRange(bussinessErrors);
}
else
{
_errors.Add(propertyName, bussinessErrors);
}
}
if (results.Any())
{
_errors[propertyName] = results.Select(c => c.ErrorMessage).ToList();
}
else if (bussinessErrors == null || bussinessErrors != null && !bussinessErrors.Any())
{
_errors.Remove(propertyName);
}
ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(propertyName));
}
public StrobeEffectViewModel()
{
var canGenerate = this.WhenAnyValue(
x => x.Color1,
x => x.Color2,
x => x.HasErrors,
(c1, c2, err) => !err && c1 != c2 && ShowLightViewModel.GetShowlightType(c1) == ShowLightViewModel.GetShowlightType(c2));
this.WhenAnyValue(x => x.StartTime, x => x.EndTime)
.Subscribe(tuple =>
{
var(startTime, endTime) = tuple;
bool errorsChanged = false;
if (_errors.ContainsKey(nameof(EndTime)))
{
_errors.Remove(nameof(EndTime));
errorsChanged = true;
}
if (endTime <= startTime)
{
_errors.Add(nameof(EndTime), "End time cannot be less than start time.");
errorsChanged = true;
}
if (errorsChanged)
{
ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(nameof(EndTime)));
this.RaisePropertyChanged(nameof(HasErrors));
}
});
Generate = ReactiveCommand.Create(GenerateStrobeEffect, canGenerate);
Generate.BindTo(this, x => x.GeneratedShowlights);
}
public void ClearPropertyValidationErrors([CallerMemberName] string propertyName = "")
{
if (!_Errors.ContainsKey(propertyName))
{
return;
}
var lst = _Errors[propertyName].ToList();
foreach (var e in lst)
{
if (_ErrorsTypes.TryGetValue(propertyName, out var propErrTypes) &&
propErrTypes.TryGetValue(e, out var errType) &&
errType.FullName == "System.Windows.Controls.NotifyDataErrorValidationRule")
{
_Errors[propertyName]
.Remove(e);
}
if (NotifyErrorsChangedEnabled)
{
ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(propertyName));
}
NotifyPropertyChanged(nameof(IsValid));
}
}
public void Validate([CallerMemberName] string propertyName = "")
{
if (_validator == null)
{
throw new NullReferenceException("An instance of IValidator is required");
}
var result = _validator.Validate(this);
var errorMessages = result.Errors.Where(x => x.PropertyName == propertyName)
.Select(em => em.ErrorMessage).ToList();
if (_errors.ContainsKey(propertyName))
{
_errors.Remove(propertyName);
}
if (errorMessages.Count > 0)
{
foreach (var message in errorMessages)
{
if (_errors.ContainsKey(propertyName))
{
_errors[propertyName].Add(message);
}
else
{
_errors.Add(propertyName, new List <string> {
message
});
}
}
}
ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(propertyName));
}
/// <summary>
/// Sets the errors for the given property.
/// If <paramref name="errors"/> is null or empty, the errors of <paramref name="propertyName"/> are cleared.
/// If an entry of <paramref name="errors"/> is null or empty, it is ignored.
/// </summary>
protected void SetErrors(string propertyName, IEnumerable <string> errors)
{
if (errors == null)
{
ClearErrors(propertyName);
return;
}
var errorList = errors.Where(s => !string.IsNullOrEmpty(s)).ToList();
if (!errorList.Any())
{
ClearErrors(propertyName);
return;
}
IList <string> oldList;
if (_errorDict.TryGetValue(propertyName, out oldList) && oldList.Count == errorList.Count &&
oldList.SequenceEqual(errorList))
{
return;
}
_errorDict[propertyName] = errorList;
ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(propertyName));
}
/// <summary>
/// Notifies listeners that the errors of a property have changed.
/// </summary>
/// <param name="propertyName">Name of the property used to notify listeners.</param>
private void OnErrorsChanged(string propertyName)
{
ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(propertyName));
}
protected virtual void ClearErrors(string propertyName)
{
errors.Remove(propertyName);
ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(propertyName));
}
protected virtual void OnErrorsChanged(string propertyName)
{
ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(propertyName));
base.OnPropertyChanged(nameof(HasErrors));
}
/// <summary>
/// Validates a property with a specified name and a given input value.
/// </summary>
/// <param name="value">The value to test for the specified property.</param>
/// <param name="propertyName">The name of the property to validate.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="propertyName"/> is <see langword="null"/>.</exception>
private void ValidateProperty(object?value, string?propertyName)
{
if (propertyName is null)
{
ThrowArgumentNullExceptionForNullPropertyName();
}
// Check if the property had already been previously validated, and if so retrieve
// the reusable list of validation errors from the errors dictionary. This list is
// used to add new validation errors below, if any are produced by the validator.
// If the property isn't present in the dictionary, add it now to avoid allocations.
if (!this.errors.TryGetValue(propertyName !, out List <ValidationResult>?propertyErrors))
{
propertyErrors = new List <ValidationResult>();
this.errors.Add(propertyName !, propertyErrors);
}
bool errorsChanged = false;
// Clear the errors for the specified property, if any
if (propertyErrors.Count > 0)
{
propertyErrors.Clear();
errorsChanged = true;
}
// Validate the property, by adding new errors to the existing list
bool isValid = Validator.TryValidateProperty(
value,
new ValidationContext(this, null, null)
{
MemberName = propertyName
},
propertyErrors);
// Update the shared counter for the number of errors, and raise the
// property changed event if necessary. We decrement the number of total
// errors if the current property is valid but it wasn't so before this
// validation, and we increment it if the validation failed after being
// correct before. The property changed event is raised whenever the
// number of total errors is either decremented to 0, or incremented to 1.
if (isValid)
{
if (errorsChanged)
{
this.totalErrors--;
if (this.totalErrors == 0)
{
OnPropertyChanged(HasErrorsChangedEventArgs);
}
}
}
else if (!errorsChanged)
{
this.totalErrors++;
if (this.totalErrors == 1)
{
OnPropertyChanged(HasErrorsChangedEventArgs);
}
}
// Only raise the event once if needed. This happens either when the target property
// had existing errors and is now valid, or if the validation has failed and there are
// new errors to broadcast, regardless of the previous validation state for the property.
if (errorsChanged || !isValid)
{
ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(propertyName));
}
}
public void RaiseErrorsChanged(string sPropertyName)
{
_isRaiseErrorsChanged = false;
ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(sPropertyName));
}
void Validate([CallerMemberName] string propertyName = null)
{
List <string> errors;
if (!_errors.TryGetValue(propertyName, out errors))
{
errors = new List <string>();
_errors[propertyName] = errors;
}
StringBuilder builder;
switch (propertyName)
{
case nameof(LoginName):
errors.Clear();
if (LoginName?.Length > 0 && !Regex.IsMatch(LoginName, @"^[\x21-\x7E]+$"))
{
errors.Add("Invalid symbols (space is not allowed)");
}
if (LoginName?.Length > 32)
{
errors.Add("Max length is 32");
}
ErrorText = "";
builder = new StringBuilder();
builder.Append(ErrorText);
foreach (var str in errors)
{
builder.Append(str + "\r\n");
}
ErrorText = builder.ToString().TrimEnd(new[] { '\r', '\n' });
break;
case nameof(LoginPassword):
errors.Clear();
if (LoginPassword?.ConvertToUnsecureString()?.Length > 0 && !Regex.IsMatch(LoginPassword?.ConvertToUnsecureString() ?? "", @"^[\x20-\x7E]+$"))
{
errors.Add("Invalid symbols");
}
if (LoginPassword?.ConvertToUnsecureString()?.Length > 32)
{
errors.Add("Max length is 32");
}
ErrorText = "";
builder = new StringBuilder();
builder.Append(ErrorText);
foreach (var str in errors)
{
builder.Append(str + "\r\n");
}
ErrorText = builder.ToString().TrimEnd(new[] { '\r', '\n' });
break;
case nameof(NewGameText):
errors.Clear();
builder = new StringBuilder();
if (NewGameText?.Length > 0 && !Regex.IsMatch(NewGameText, @"^[\x20-\x7E]+$"))
{
errors.Add("Invalid symbols");
}
if (NewGameText?.Length > 32)
{
errors.Add("Max length is 32");
}
builder = new StringBuilder();
GameTextErrorText = "";
builder.Append(ErrorText);
foreach (var str in errors)
{
builder.Append(str + "\r\n");
}
GameTextErrorText = builder.ToString().TrimEnd(new[] { '\r', '\n' });
break;
}
HasErrors = _errors.Any(o => o.Value?.Count > 0);
ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(propertyName));
}
public void RaiseErrorsChanged(string propertyName)
{
ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(propertyName));
}
private void ValidatorOnErrorsChanged(object sender, DataErrorsChangedEventArgs args)
{
ErrorsChanged?.Invoke(sender, args);
}
/// <summary>
/// Raises this object's <see cref="ErrorsChanged"/> event.
/// </summary>
/// <inheritdoc cref="DataErrorsChangedEventArgs(string)"/>
protected void RaiseErrorsChanged(string propertyName)
{
ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(propertyName));
RaisePropertyChanged(nameof(HasErrors));
}
private void OnErrorsChanged(string propertyName)
{
ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(propertyName));
NotifyOfPropertyChange(nameof(HasErrors));
}
private void OnValidations_ErrorsChanged(object?sender, DataErrorsChangedEventArgs e)
{
ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(e.PropertyName));
}
protected virtual void OnErrorsChanged(string propertyName)
{
ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(propertyName));
}
