static void ThrowForUnsuccessfulValidationIfApplicable(IQueryableValidationResult result, ResolvedValidationOptions options)
{
if (ShouldThrowForError(options) && result.RuleResults.Any(x => x.Outcome == Rules.RuleOutcome.Errored))
{
var message = String.Format(Resources.ExceptionMessages.GetExceptionMessage("ErrorInValidation"),
nameof(ResolvedValidationOptions),
nameof(ResolvedValidationOptions.RuleThrowingBehaviour),
nameof(RuleThrowingBehaviour),
options.RuleThrowingBehaviour,
nameof(ValidationResult),
nameof(RuleOutcome.Errored));
throw new ValidationException(message, (ValidationResult)result);
}
if (ShouldThrowForFailure(options) && result.RuleResults.Any(x => x.Outcome == Rules.RuleOutcome.Failed))
{
var message = String.Format(Resources.ExceptionMessages.GetExceptionMessage("FailureInValidation"),
nameof(ResolvedValidationOptions),
nameof(ResolvedValidationOptions.RuleThrowingBehaviour),
nameof(RuleThrowingBehaviour),
options.RuleThrowingBehaviour,
nameof(ValidationResult),
nameof(RuleOutcome.Errored),
nameof(RuleOutcome.Failed));
throw new ValidationException(message, (ValidationResult)result);
}
}
internal static SerializableValidationResult ToSerializableValidationResult(IQueryableValidationResult result)
{
return(new SerializableValidationResult
{
RuleResults = result.RuleResults
.Select(ruleResult =>
{
return new SerializableValidationRuleResult
{
MemberName = ruleResult.Identifier?.MemberName,
ObjectIdentityString = ruleResult.Identifier?.ObjectIdentity?.ToString(),
RuleTypeName = ruleResult.Identifier?.RuleType.AssemblyQualifiedName,
RuleName = ruleResult.Identifier?.RuleName,
ValidatedTypeName = ruleResult.Identifier?.ValidatedType.AssemblyQualifiedName,
Outcome = ruleResult.Outcome,
Message = ruleResult.Message,
ExceptionString = ruleResult.Exception?.ToString(),
};
})
.ToArray(),
});
}
internal static IQueryableValidationResult <TDerived> PolymorphicAs <TValidated, TDerived>(IQueryableValidationResult <TValidated> results)
where TDerived : TValidated
{
if (results is null)
{
throw new ArgumentNullException(nameof(results));
}
if (!(results.ManifestValue is IHasPolymorphicTypes poly))
{
var message = String.Format(Resources.ExceptionMessages.GetExceptionMessage("MustImplementPolymorphicInterface"),
typeof(IHasPolymorphicTypes).Name,
results.ManifestValue.GetType().FullName);
throw new ArgumentException(message, nameof(results));
}
var polymorphicManifest = poly.PolymorphicTypes.FirstOrDefault(x => x.ValidatedType == typeof(TDerived));
if (polymorphicManifest is null)
{
var message = String.Format(Resources.ExceptionMessages.GetExceptionMessage("MustHaveMatchingPolymorphicManifest"),
results.ManifestValue.ValidatedType.FullName,
typeof(TDerived).FullName);
throw new ArgumentException(message, nameof(results));
}
return(new SubsetOfValidationResults <TDerived>(results.RuleResults, polymorphicManifest));
}
internal static IQueryableValidationResult <TValidated> WithoutSuccesses <TValidated>(IQueryableValidationResult <TValidated> results)
{
if (results is null)
{
throw new ArgumentNullException(nameof(results));
}
return(new SubsetOfValidationResults <TValidated>(results.Where(x => x.Outcome != Rules.RuleOutcome.Passed), results.ManifestValue));
}
internal static IQueryableValidationResult <TValidated> ForOnlyTheSameValue <TValidated>(IQueryableValidationResult <TValidated> results)
{
if (results is null)
{
throw new ArgumentNullException(nameof(results));
}
var filteredRuleResults = results.RuleResults.Where(new RuleResultIsForDescendentOfValue(results.ManifestValue, false));
return(new SubsetOfValidationResults <TValidated>(filteredRuleResults, results.ManifestValue));
}
internal static IQueryableValidationResult <TItem> ForMatchingMemberItem <TValidated, TItem>(IQueryableValidationResult <TValidated> results,
Expression <Func <TValidated, IEnumerable <TItem> > > memberExpression,
TItem item)
{
if (results is null)
{
throw new ArgumentNullException(nameof(results));
}
var member = Reflection.Reflect.Member(memberExpression);
var collectionValue = results.ManifestValue.Children.FirstOrDefault(x => x.MemberName == member.Name);
if (collectionValue is null)
{
var message = String.Format(Resources.ExceptionMessages.GetExceptionMessage("NoMatchingMemberInManifest"),
typeof(TValidated).FullName,
member.Name);
throw new ArgumentException(message, nameof(memberExpression));
}
if (collectionValue.CollectionItemValue is null)
{
var message = string.Format(Resources.ExceptionMessages.GetExceptionMessage("ValueMustBeACollection"),
typeof(TValidated).FullName,
member.Name,
nameof(ForMatchingMemberItem));
throw new ArgumentException(message, nameof(memberExpression));
}
var filteredRuleResults = results.RuleResults.Where(new RuleResultIsForDescendentOfValue(collectionValue.CollectionItemValue, item));
return(new SubsetOfValidationResults <TItem>(filteredRuleResults, collectionValue.CollectionItemValue));
}
async Task <IEnumerable <ValidationRuleResult> > GetRuleResultsWithMessagesAsync(IQueryableValidationResult result, CancellationToken cancellationToken)
{
var results = new List <ValidationRuleResult>();
foreach (var ruleResult in result.RuleResults)
{
cancellationToken.ThrowIfCancellationRequested();
results.Add(await GetRuleResultWithMessageAsync(ruleResult, cancellationToken).ConfigureAwait(false));
}
return(results);
}
/// <inheritdoc/>
public async Task <IQueryableValidationResult <TValidated> > GetResultWithMessagesAsync <TValidated>(IQueryableValidationResult <TValidated> result, CancellationToken cancellationToken = default)
{
var resultsWithMessages = await GetRuleResultsWithMessagesAsync(result, cancellationToken).ConfigureAwait(false);
return(new ValidationResult <TValidated>(resultsWithMessages, ((ValidationResult <TValidated>)result).Manifest));
}
