public static Task <ValidationResult> ValidateUpdateAsync <T>(
this IValidator validator,
T instance,
T existingRecordInstance)
{
var ruleSet = RuleSetConstants.Update;
var selector = new RulesetValidatorSelector(ruleSet.Split(',', ';'));
if (typeof(T) == instance.GetType())
{
return(validator.ValidateAsync(
new ScimValidationContext <T>(instance, existingRecordInstance, new PropertyChain(), selector)));
}
// we are dealing with a polymorphic type
var resourceType = instance.GetType();
var validationContext = (ValidationContext)Activator.CreateInstance(
typeof(ScimValidationContext <>).MakeGenericType(resourceType),
instance,
existingRecordInstance,
new PropertyChain(),
selector);
return(validator.ValidateAsync(validationContext));
}
private ValidationContext <T> CreateContextForRulesToAplyOnValidate(T instance, PropertyChain propertychain = null)
{
var selector = new RulesetValidatorSelector(RulesToAplyOnValidate.ToArray());
var context = new ValidationContext <T>(instance, new PropertyChain(), selector);
return(context);
}
public static ValidationResult Validate <T>(this IValidator <T> validator, T instance, IList <string> rules)
{
var selector = new RulesetValidatorSelector(rules.ToArray());
var context = new ValidationContext <T>(instance, new PropertyChain(), selector);
return(validator.Validate(context));
}
public static async Task <TestValidationResult <T> > TestValidateAsync <T>(this IValidator <T> validator, T objectToTest, CancellationToken cancellationToken, string ruleSet) where T : class
{
return(await validator.TestValidateAsync(objectToTest, options => {
if (ruleSet != null)
{
options.IncludeRuleSets(RulesetValidatorSelector.LegacyRulesetSplit(ruleSet));
}
}, cancellationToken));
}
public static TestValidationResult <T> TestValidate <T>(this IValidator <T> validator, T objectToTest, string ruleSet) where T : class
{
return(validator.TestValidate(objectToTest, options => {
if (ruleSet != null)
{
options.IncludeRuleSets(RulesetValidatorSelector.LegacyRulesetSplit(ruleSet));
}
}));
}
/// <summary>
/// Performs validation and then throws an exception if validation fails.
/// </summary>
/// <param name="validator">The validator this method is extending.</param>
/// <param name="instance">The instance of the type we are validating.</param>
/// <param name="applyTo">The ruleset to validate against.</param>
public static void ValidateAndThrow <T>(this IValidator <T> validator, T instance, ApplyTo applyTo)
{
var ruleSet = applyTo.ToString().ToUpper();
validator.Validate(instance, options => {
options.IncludeRuleSets(RulesetValidatorSelector.LegacyRulesetSplit(ruleSet));
options.ThrowOnFailures();
});
}
public void Validate(T instance, params string[] ruleSetsToExecute)
{
var ruleSetValidatorSelector = new RulesetValidatorSelector(ruleSetsToExecute);
var validationContext = new ValidationContext <T>(instance, null, ruleSetValidatorSelector);
var validationResult = Validate(validationContext);
HandleValidationFailure(validationResult, instance);
}
public void AssertValid <T>(T instance, params string[] ruleSetsToExecute)
{
var ruleSetValidatorSelector = new RulesetValidatorSelector(ruleSetsToExecute);
var validationContext = new ValidationContext <T>(instance, null, ruleSetValidatorSelector);
var validator = _validatorAbstractFactory.Resolve <T>();
var validationResult = validator.Validate(validationContext);
HandleValidationFailure(validationResult, instance);
}
public static async Task ValidateAndThrowAsync <T>(this IValidator <T> validator, T instance, string ruleSet, CancellationToken cancellationToken = default)
{
await validator.ValidateAsync(instance, options => {
if (ruleSet != null)
{
options.IncludeRuleSets(RulesetValidatorSelector.LegacyRulesetSplit(ruleSet));
}
options.ThrowOnFailures();
}, cancellationToken);
}
public static void ValidateAndThrow <T>(this IValidator <T> validator, T instance, string ruleSet)
{
validator.Validate(instance, options => {
if (ruleSet != null)
{
options.IncludeRuleSets(RulesetValidatorSelector.LegacyRulesetSplit(ruleSet));
}
options.ThrowOnFailures();
});
}
public static void MyValidate <T>(this IValidator <T> validator, T instance, params string[] rules)
{
var selector = new RulesetValidatorSelector(rules);
var context = new ValidationContext <T> (instance, new PropertyChain(), selector);
var validationResult = validator.Validate(context);
if (!validationResult.IsValid)
{
throw new ValidationException(validationResult.Errors);
}
}
public static Task <ValidationResult> ValidateAsync <T>(this IValidator <T> validator, T instance, CancellationToken cancellationToken = default, IValidatorSelector selector = null, string ruleSet = null)
{
return(validator.ValidateAsync(instance, options => {
if (selector != null)
{
options.UseCustomSelector(selector);
}
if (ruleSet != null)
{
options.IncludeRuleSets(RulesetValidatorSelector.LegacyRulesetSplit(ruleSet));
}
}, cancellationToken));
}
public static ValidationResult Validate <T>(this IValidator <T> validator, T instance, IValidatorSelector selector = null, string ruleSet = null)
{
return(validator.Validate(instance, options => {
if (selector != null)
{
options.UseCustomSelector(selector);
}
if (ruleSet != null)
{
options.IncludeRuleSets(RulesetValidatorSelector.LegacyRulesetSplit(ruleSet));
}
}));
}
/// <summary>
/// Builds a validator selector from the options specified in the attribute's properties.
/// </summary>
public IValidatorSelector ToValidatorSelector() {
IValidatorSelector selector;
if(! string.IsNullOrEmpty(RuleSet)) {
var rulesets = RuleSet.Split(',', ';');
selector = new RulesetValidatorSelector(rulesets);
}
else if(! string.IsNullOrEmpty(Properties)) {
var properties = Properties.Split(',', ';');
selector = new MemberNameValidatorSelector(properties);
}
else {
selector = new DefaultValidatorSelector();
}
return selector;
}
/// <summary>
/// Builds a validator selector from the options specified in the attribute's properties.
/// </summary>
public IValidatorSelector ToValidatorSelector()
{
IValidatorSelector selector;
if (!string.IsNullOrEmpty(RuleSet))
{
var rulesets = RuleSet.Split(',', ';');
selector = new RulesetValidatorSelector(rulesets);
}
else if (!string.IsNullOrEmpty(Properties))
{
var properties = Properties.Split(',', ';');
selector = new MemberNameValidatorSelector(properties);
}
else
{
selector = new DefaultValidatorSelector();
}
return(selector);
}
public static ValidationResult Validate <T>(this IValidator <T> validator, T instance, IValidatorSelector selector = null, string ruleSet = null)
{
if (selector != null && ruleSet != null)
{
throw new InvalidOperationException("Cannot specify both an IValidatorSelector and a RuleSet.");
}
if (selector == null)
{
selector = new DefaultValidatorSelector();
}
if (ruleSet != null)
{
selector = new RulesetValidatorSelector(ruleSet);
}
var context = new ValidationContext <T>(instance, new PropertyChain(), selector);
return(validator.Validate(context));
}
