public ValidationError Validate(INewPasswordValidationContext context)
{
if (!string.IsNullOrWhiteSpace(context.CurrentPassword) &&
context.CurrentPassword == context.Password)
{
return(PasswordPolicyValidationErrors.NotCurrentPassword.Create(context.PropertyName));
}
return(null);
}
public virtual async Task ValidateAsync(INewPasswordValidationContext context)
{
ValidateContext(context);
var passwordPolicy = _passwordPolicyConfigurationFactory.Create(context.UserAreaCode);
var errors = await passwordPolicy.ValidateAsync(context);
if (errors.Any())
{
throw new ValidationErrorException(errors.First());
}
}
public ValidationError Validate(INewPasswordValidationContext context)
{
var lowerPassword = context
.Password
.ToLowerInvariant();
if (IsCodeSequence(lowerPassword))
{
return(PasswordPolicyValidationErrors.NotSequential.Create(context.PropertyName));
}
return(null);
}
public ValidationError Validate(INewPasswordValidationContext context)
{
if (Matches(context.Password, context.Email))
{
return(PasswordPolicyValidationErrors.NotPersonalData.Email.Create(context.PropertyName));
}
if (Matches(context.Password, context.Username))
{
return(PasswordPolicyValidationErrors.NotPersonalData.Username.Create(context.PropertyName));
}
return(null);
}
public ValidationError Validate(INewPasswordValidationContext context)
{
if (MinUniqueCharacters > 1 && context
.Password
.Distinct()
.Count() < MinUniqueCharacters)
{
return(PasswordPolicyValidationErrors
.MinUniqueCharacters
.Customize()
.WithMessageFormatParameters(MinUniqueCharacters)
.WithProperties(context.PropertyName)
.Create());
}
return(null);
}
private static void ValidateContext(INewPasswordValidationContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (string.IsNullOrEmpty(context.Password))
{
throw new ArgumentException("Cannot validate a null or empty password value.");
}
if (string.IsNullOrEmpty(context.UserAreaCode))
{
throw new ArgumentException($"{nameof(INewPasswordValidationContext)} must supply a {nameof(INewPasswordValidationContext.UserAreaCode)}.");
}
}
public ValidationError Validate(INewPasswordValidationContext context)
{
if (MaxLength == 0)
{
throw new InvalidOperationException($"{nameof(Configure)} has not been called.");
}
if (context.Password.Length > MaxLength)
{
return(PasswordPolicyValidationErrors
.MaxLengthExceeded
.Customize()
.WithMessageFormatParameters(MaxLength)
.WithProperties(context.PropertyName)
.Create());
}
return(null);
}
public async Task <ICollection <ValidationError> > ValidateAsync(
INewPasswordValidationContext newPasswordValidatonContext
)
{
var errors = new List <ValidationError>(_validators.Count);
foreach (var validator in _validators.OrderBy(v => v is IAsyncNewPasswordValidator))
{
ValidationError error = null;
if (validator is INewPasswordValidator syncValidator)
{
error = syncValidator.Validate(newPasswordValidatonContext);
}
else if (validator is IAsyncNewPasswordValidator asyncValidator)
{
// Only aggregate sync errors because async errors are likely slow
if (errors.Any())
{
return(errors);
}
error = await asyncValidator.ValidateAsync(newPasswordValidatonContext);
}
else
{
throw new InvalidOperationException($"Policy contains an unrecognised {nameof(INewPasswordValidatorBase)} implementation: {validator.GetType().Name}");
}
if (error != null)
{
errors.Add(error);
}
}
return(errors);
}
