public void Validate_InvalidDate_ExceptionContainsRequiredInfo()
{
ValidationFailure result = _date.Validate("banana");
Assert.NotNull(result.SourceConstraint);
Assert.AreEqual(typeof(Date), result.SourceConstraint.GetType());
}
/// <summary>
/// Creates an error validation result for this validator.
/// </summary>
/// <param name="context">The validator context</param>
/// <returns>Returns an error validation result.</returns>
protected virtual ValidationFailure CreateValidationError(PropertyValidatorContext context)
{
var messageBuilderContext = new MessageBuilderContext(context, errorSource, this);
var error = context.Rule.MessageBuilder != null
? context.Rule.MessageBuilder(messageBuilderContext)
: messageBuilderContext.GetDefaultMessage();
var failure = new ValidationFailure(context.PropertyName, error, context.PropertyValue);
failure.FormattedMessageArguments = context.MessageFormatter.AdditionalArguments;
failure.FormattedMessagePlaceholderValues = context.MessageFormatter.PlaceholderValues;
failure.ResourceName = errorSource.ResourceName;
failure.ErrorCode = (errorCodeSource != null)
? errorCodeSource.GetString(context.Instance)
: ValidatorOptions.ErrorCodeResolver(this);
if (CustomStateProvider != null)
{
failure.CustomState = CustomStateProvider(context);
}
failure.Severity = Severity;
return(failure);
}
protected void ValidateCardNumber()
{
RuleFor(order => order)
.Custom((order, context) =>
{
if (order.CardNumber == string.Empty)
{
return;
}
var detector = new CreditCardDetector(order.CardNumber);
if (!detector.IsValid())
{
var failure = new ValidationFailure(nameof(order.CardNumber), "Número do cartão inválido")
{
ErrorCode = "003"
};
context.AddFailure(failure);
}
});
RuleFor(order => order.CardNumber)
.MaximumLength(22)
.NotEmpty()
.When(cmd => cmd.PaymentMethodId == default)
.WithMessage("O número do cartão é obrigatório e deve conter ate 22 dígitos")
.WithErrorCode("004");
}
public static void SetValidatedInstance(this ValidationFailure validationFailure, object instance)
{
ArgumentUtility.CheckNotNull("validationFailure", validationFailure);
ArgumentUtility.CheckNotNull("instance", instance);
validationFailure.CustomState = instance;
}
protected ValidationResult ValidationResultFactory(string propertyName, object attemptedValue, string errorMessageTemplate, params string[] templateParams)
{
var failure = new ValidationFailure(propertyName, string.Format(errorMessageTemplate, templateParams));
failure.AttemptedValue = attemptedValue;
return(new ValidationResult(new[] { failure }));
}
private void ProcessFailure(ValidationFailure failure)
{
if (failure.Exception != null)
{
this.FlashExceptionChain(failure.Exception, failure.DisplayMessage);
return;
}
// Don't display message in flash if the key is set
if (failure.HasMessage && string.IsNullOrWhiteSpace(failure.ModelStateKey))
{
switch (failure.FlashLevel)
{
case FlashLevelType.Error:
this.FlashError(failure.DisplayMessage);
break;
case FlashLevelType.Warning:
this.FlashWarning(failure.DisplayMessage);
break;
case FlashLevelType.Info:
this.FlashInfo(failure.DisplayMessage);
break;
}
}
}
public ValidationFailure ValidateDailyFilename(SampleResult sampleResult)
{
var validationFailure = new ValidationFailure("DailyEpisodeFormat", ERROR_MESSAGE);
var parsedEpisodeInfo = Parser.Parser.ParseTitle(sampleResult.FileName);
if (parsedEpisodeInfo == null)
{
return(validationFailure);
}
if (parsedEpisodeInfo.IsDaily)
{
if (!parsedEpisodeInfo.AirDate.Equals(sampleResult.Episodes.Single().AirDate))
{
return(validationFailure);
}
return(null);
}
if (!ValidateSeasonAndEpisodeNumbers(sampleResult.Episodes, parsedEpisodeInfo))
{
return(validationFailure);
}
return(null);
}
public ValidationErrorModel(ValidationFailure error)
{
PropertyName = error.PropertyName;
ErrorMessage = error.ErrorMessage;
AttemptedValue = error.AttemptedValue;
ErrorCode = error.ErrorCode;
}
public void Should_map_ValidationFailure_to_IMessage()
{
// Arrange
var details = new ProblemDetails();
var severityMapperMock = new Mock <IValidationSeverityMapper>();
severityMapperMock
.Setup(x => x.Map(It.IsAny <Severity>()))
.Returns(OperationMessageLevel.Error);
var problemDetailsMapperMock = new Mock <IProblemDetailsMapper>();
problemDetailsMapperMock
.Setup(x => x.Map(It.IsAny <ValidationFailure>()))
.Returns(details);
var sut = new ValidationFailureMessageMapper(
severityMapperMock.Object,
problemDetailsMapperMock.Object
);
var validationFailure = new ValidationFailure("PropName", "Test Error");
// Act
var actual = sut.Map(validationFailure);
// Assert
var actualMessage = Assert.IsType <ProblemDetailsMessage>(actual);
Assert.Same(details, actualMessage.ProblemDetails);
Assert.Equal(OperationMessageLevel.Error, actualMessage.Severity);
}
protected override async Task <Domain.Team> GenerateAndValidateDomainEntity(
DatabaseContext context,
PostTeamCommand request,
CancellationToken cancellationToken)
{
if (context is null)
{
throw new ArgumentNullException(nameof(context));
}
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var teamName = request.Name.Trim();
var teamsWithSameName = await context
.Set <Domain.Team>()
.GetTeamsByName(request.Name)
.ToArrayAsync(cancellationToken);
if (teamsWithSameName.Any())
{
var error = new ValidationFailure(nameof(request.Name), string.Format(Domain.Team.ErrorMessages.NameNotUniqueFormat, teamName));
this.Logger.Information("Validation failed: a Team with the name {TeamName} already exists", request.Name);
throw new ValidationException(new ValidationFailure[] { error });
}
return(Domain.Team.CreateTeam(teamName));
}
public CustomValidationValidator()
{
RuleFor(request => request.Name).NotEmpty();
RuleFor(request => request)
.Custom((request, contex) => {
if (request.Name?.StartsWith("A") != true)
{
var propertyName = contex.ParentContext.PropertyChain.BuildPropertyName($"Name:0");
var errorMessage = $"Incorrect prefix.";
var failure = new ValidationFailure(propertyName, errorMessage)
{
ErrorCode = "NotFound"
};
contex.AddFailure(failure);
}
var nameLength = request.Name?.Length ?? 0;
var firstLetter = request.Name?.Substring(0, 1) ?? "";
var lastLetter = request.Name?.Substring(nameLength - 1, 1) ?? "";
if (firstLetter != lastLetter)
{
var propertyName = contex.ParentContext.PropertyChain.BuildPropertyName($"Name:0:1 <> Name:{nameLength - 1}:{nameLength}");
var errorMessage = $"Name inconsistency: {firstLetter} <> {lastLetter}";
var failure = new ValidationFailure(propertyName, errorMessage)
{
ErrorCode = "Inconsistency"
};
contex.AddFailure(failure);
}
});
}
public void Validate_Invalid_ExceptionContainsRequiredInfo()
{
ValidationFailure result = _alphanum.Validate(" ");
Assert.NotNull(result.SourceConstraint);
Assert.AreEqual(typeof(AlphaNumeric), result.SourceConstraint.GetType());
}
public ValidationError(ValidationFailure error)
{
this.AttemptedValue = error.AttemptedValue;
this.CustomState = error.CustomState;
this.ErrorMessage = error.ErrorMessage;
this.PropertyName = error.PropertyName;
}
public bool VerifyLigne(LigneAnnexeUn ligne, IList <ValidationFailure> errors)
{
if (ligne == null)
{
throw new ArgumentNullException("ligne");
}
if (errors == null)
{
throw new ArgumentNullException("errors");
}
// vider la collection d'erreurs
errors.Clear();
// verifier si les donnees de la ligne sont valides
var result = _validator.Validate(ligne);
if (!result.IsValid)
{
result.Errors.ForEach(errors.Add);
return(false);
}
// verifier si le beneficiaire a deja une ligne dans l'annexe
if (_repository.ExistBeneficiaire(ligne.BeneficiaireIdent))
{
var failureMessage = string.Format("Le beneficiaire [{0}, {1}] a deja une ligne dans l'annexe 1",
ligne.Beneficiaire, ligne.BeneficiaireIdent);
var failure = new ValidationFailure("BeneficiaireIdent", failureMessage);
errors.Add(failure);
return(false);
}
return(true);
}
public void Time_AfterAvailability_IsValidFalse()
{
_viewModel.StartTime = _viewModel.Availability.DateTime
.Add(_viewModel.Availability.TimeSpan.Add(new TimeSpan(1, 0, 0)))
.TimeOfDay;
_viewModel.EndTime = _viewModel.StartTime.Add(new TimeSpan(1, 0, 0));
var expectedFailuare = new ValidationFailure("EndTime", "The appointment finishes later than the availability");
var expectedFailuare2 = new ValidationFailure("StartTime", "The appointment does not start within the available time");
var results = _validator.Validate(_viewModel);
results.IsValid.Should().Be(false);
results.Errors.Count.Should().Be(2);
var failuareResults = results.Errors.First();
failuareResults.PropertyName.Should().Be(expectedFailuare.PropertyName);
failuareResults.ErrorMessage.Should().Be(expectedFailuare.ErrorMessage);
var failuareResults2 = results.Errors[1];
failuareResults2.PropertyName.Should().Be(expectedFailuare2.PropertyName);
failuareResults2.ErrorMessage.Should().Be(expectedFailuare2.ErrorMessage);
}
/// <summary>
/// Creates an error validation result for this validator.
/// </summary>
/// <param name="context">The validator context</param>
/// <returns>Returns an error validation result.</returns>
protected virtual ValidationFailure CreateValidationError(PropertyValidatorContext context)
{
var messageBuilderContext = new MessageBuilderContext(context, this);
var error = context.Rule.MessageBuilder != null
? context.Rule.MessageBuilder(messageBuilderContext)
: messageBuilderContext.GetDefaultMessage();
var failure = new ValidationFailure(context.PropertyName, error, context.PropertyValue);
#pragma warning disable 618
failure.FormattedMessageArguments = context.MessageFormatter.AdditionalArguments;
#pragma warning restore 618
failure.FormattedMessagePlaceholderValues = context.MessageFormatter.PlaceholderValues;
#pragma warning disable 618
failure.ErrorCode = ErrorCodeSource?.GetString(context) ?? ValidatorOptions.Global.ErrorCodeResolver(this);
#pragma warning restore 618
if (CustomStateProvider != null)
{
failure.CustomState = CustomStateProvider(context);
}
if (SeverityProvider != null)
{
failure.Severity = SeverityProvider(context);
}
return(failure);
}
protected async override Task <Users> Insert(Users item)
{
USERS data = MapToEntity(item);
data.USERID = GenerateId();
DateTime now = DateTime.UtcNow;
data.DATECREATED = now;
data.DATELASTLOGIN = now;
data.DATECHANGEPASS = now;
data.PASSWORDFORMAT = 2;
//data.PASSWORDSALT = Crypto.GenerateSalt(32);
data.PASSWORD = Crypto.HashPassword(item.Password);
_ctx.USERS.Add(data);
_ctx.Entry(data).State = EntityState.Added;
if (await _ctx.SaveChangesAsync() <= 0)
{
var error = new ValidationFailure("User", string.Format(ValidationErrorMessage.GenericDBSaveError, "User"));
item.Validation.Errors.Add(error);
_logger.Log("FATAL", "Save User", item, error.ErrorMessage);
return(item);
}
_logger.Log("INFO", "Add User", item, "Successful.");
item.Userid = data.USERID;
return(item);
}
public static ValidationFailure HaveAValidHourRate(this FurtherVacancyDetailsViewModel viewModel, decimal?amount, string parentPropertyName, string nameOfTestedProperty)
{
var unitToMeasure = viewModel.Wage.CustomType == CustomWageType.Ranged
? viewModel.Wage.RangeUnit
: viewModel.Wage.Unit;
var unitPrecondition = unitToMeasure != WageUnit.NotApplicable;
if (amount.HasValue && viewModel.Wage.Classification == WageClassification.Custom && unitPrecondition && viewModel.Wage.HoursPerWeek.HasValue && viewModel.Wage.HoursPerWeek > 0)
{
var hourRate = GetHourRate(amount.Value, unitToMeasure, viewModel.Wage.HoursPerWeek.Value);
DateTime possibleStartDate;
var wageRange = viewModel.VacancyDatesViewModel.GetWageRangeForPossibleStartDate(out possibleStartDate);
if (hourRate < wageRange.ApprenticeMinimumWage)
{
var propertyName = nameOfTestedProperty;
if (!string.IsNullOrEmpty(parentPropertyName))
{
propertyName = parentPropertyName + "." + propertyName;
}
var validationFailure = new ValidationFailure(propertyName, wageRange.ValidationErrorMessage, amount);
return(validationFailure);
}
}
return(null);
}
public ValidationFailure ValidateAnimeFilename(SampleResult sampleResult)
{
var validationFailure = new ValidationFailure("AnimeEpisodeFormat", ERROR_MESSAGE);
var parsedEpisodeInfo = Parser.Parser.ParseTitle(sampleResult.FileName);
if (parsedEpisodeInfo == null)
{
return(validationFailure);
}
if (parsedEpisodeInfo.AbsoluteEpisodeNumbers.Any())
{
if (!parsedEpisodeInfo.AbsoluteEpisodeNumbers.First().Equals(sampleResult.Episodes.First().AbsoluteEpisodeNumber))
{
return(validationFailure);
}
return(null);
}
if (!ValidateSeasonAndEpisodeNumbers(sampleResult.Episodes, parsedEpisodeInfo))
{
return(validationFailure);
}
return(null);
}
public TypeValidationFailure(Type validatorType, ValidationFailure failure)
{
Guard.AgainstNull(validatorType, nameof(validatorType));
Guard.AgainstNull(failure, nameof(failure));
ValidatorType = validatorType;
Failure = failure;
}
protected virtual IErrorBuilder CreateErrorBuilder(
IMiddlewareContext context,
string argumentName,
IValidator validator,
ValidationFailure failure)
{
var builder = ErrorBuilder.New()
.SetPath(context.Path)
.SetMessage(failure.ErrorMessage)
.SetCode("FairyBread_ValidationError")
.SetExtension("argumentName", argumentName)
.SetExtension("validatorName", validator.GetType().Name)
.SetExtension("errorCode", failure.ErrorCode)
.SetExtension("errorMessage", failure.ErrorMessage)
.SetExtension("attemptedValue", failure.AttemptedValue)
.SetExtension("severity", failure.Severity)
.SetExtension("formattedMessagePlaceholderValues", failure.FormattedMessagePlaceholderValues);
if (!string.IsNullOrWhiteSpace(failure.PropertyName))
{
builder = builder
.SetExtension("propertyName", failure.PropertyName);
}
return(builder);
}
public ValidationFailureShim(ValidationFailure failure)
{
ErrorCode = failure.ErrorCode;
PropertyName = failure.PropertyName;
ErrorMessage = failure.ErrorMessage;
AttemptedValue = failure.AttemptedValue;
}
private ResultError MapToResultError(ValidationFailure failure)
{
return(new ResultError(failure.ErrorCode,
failure.ErrorMessage,
failure.PropertyName,
failure.AttemptedValue));
}
public async Task <Usersinrole> DeleteAsync(Usersinrole item)
{
try
{
var validator = new UserRoleDeleteValidator(_ctx);
item.Validation = validator.Validate(item);
if (!item.Validation.IsValid)
{
return(await Task.FromResult(item));
}
USERSINROLE data = MapToEntity(item);
_ctx.Entry(data).State = EntityState.Deleted;
var error = new ValidationFailure("Role", string.Format(ValidationErrorMessage.GenericDBDeleteError, "Role"));
item.Validation.Errors.Add(error);
await _ctx.SaveChangesAsync();
_logger.Log("FATAL", "Delete User in Role", item, error.ErrorMessage);
return(item);
}
catch (Exception ex)
{
item.Validation = CommonFn.CreateValidationError(ValidationErrorMessage.GenericDBDeleteError, "Usersinrole");
_logger.Log("INFO", "Delete User in Role", item, "Successful.");
return(item);
}
}
public void Given_a_model_with_invalid_iban_when_validating_should_contain_validation_errors(string attemptedIbanValue)
{
_testModel.BankAccountNumber = attemptedIbanValue;
const string expectedFormattedPropertyName = "Bank Account Number";
var expectedValidationFailure = new ValidationFailure(nameof(_testModel.BankAccountNumber), $"'{expectedFormattedPropertyName}' is not a valid IBAN.")
{
AttemptedValue = attemptedIbanValue,
ErrorCode = nameof(FluentIbanValidator),
FormattedMessageArguments = new object[0],
FormattedMessagePlaceholderValues = new Dictionary <string, object>
{
{ "PropertyName", expectedFormattedPropertyName },
{ "PropertyValue", attemptedIbanValue },
{ "Error", new InvalidLengthResult() }
}
};
// Act
var actual = _sut.Validate(_testModel);
// Assert
actual.IsValid.Should().BeFalse("because one validation error should have occurred");
actual.Errors.Should()
.HaveCount(1, "because one validation error should have occurred")
.And.Subject.Single()
.Should()
.BeEquivalentTo(expectedValidationFailure);
}
public void CreateNew_UseConstraint()
{
// Clean up any existing regexes
CatalogueRepository.GetAllObjects <StandardRegex>("WHERE ConceptName = 'Fish'").ToList().ForEach(r => r.DeleteInDatabase());
var regex = new StandardRegex(CatalogueRepository);
try
{
Assert.IsNotNull(regex.ConceptName);
Assert.IsTrue(string.IsNullOrEmpty(regex.Description));
regex.ConceptName = "Fish";
regex.Regex = "^(Fish)$";
regex.SaveToDatabase();
StandardRegexConstraint constraint = new StandardRegexConstraint(CatalogueRepository);
constraint.CatalogueStandardRegex = regex;
Assert.IsNull(constraint.Validate("Fish", null, null));
ValidationFailure failure = constraint.Validate("FishFingers", null, null);
Assert.IsNotNull(failure);
}
finally
{
regex.DeleteInDatabase();
}
}
private async Task AttemptDeleteRepair(
ContentTypeDefinition contentTypeDefinition,
IContentItemVersion contentItemVersion,
ValidateAndRepairResult result,
ValidationFailure failure)
{
var deleteGraphSyncer = _serviceProvider.GetRequiredService <IDeleteGraphSyncer>();
try
{
await deleteGraphSyncer.DeleteIfAllowed(failure.ContentItem, contentItemVersion, SyncOperation.Delete);
}
catch (Exception ex)
{
_logger.LogWarning(ex, "Repair of deleted {ContentItem} failed.", failure.ContentItem);
}
(bool validated, string?validationFailureReason) =
await ValidateDeletedContentItem(failure.ContentItem, contentTypeDefinition, contentItemVersion);
if (validated)
{
_logger.LogInformation("Repair was successful on deleted {ContentType} {ContentItemId} in {CurrentGraph}.",
failure.ContentItem.ContentType,
failure.ContentItem.ContentItemId,
GraphDescription(_currentGraph !));
result.Repaired.Add(new ValidatedContentItem(failure.ContentItem, ValidateType.Delete));
}
else
{
string message = $"Repair was unsuccessful.{Environment.NewLine}{{ValidationFailureReason}}.";
_logger.LogWarning(message, validationFailureReason);
result.RepairFailures.Add(new RepairFailure(failure.ContentItem, validationFailureReason !, ValidateType.Delete));
}
}
protected override async Task <Applications> Insert(Applications item)
{
try
{
APPLICATIONS data = MapToEntity(item);
data.APPLICATIONID = GenerateId();
data.APPLICAITONSECRET = GenerateId();
_ctx.APPLICATIONS.Add(data);
_ctx.Entry(data).State = System.Data.Entity.EntityState.Added;
if (await _ctx.SaveChangesAsync() <= 0)
{
var error = new ValidationFailure("Application", string.Format(ValidationErrorMessage.GenericDBSaveError, "Application"));
item.Validation.Errors.Add(error);
_logger.Log("FATAL", "Save Application", item, error.ErrorMessage);
item.Validation.Errors.Add(error);
return(item);
}
_logger.Log("FATAL", "Add Application", item, "Successful.");
return(await GetByNameAsync(data.APPLICATIONNAME));
}
catch (Exception ex)
{
item.Validation = CommonFn.CreateValidationError(ValidationErrorMessage.GenericDBDeleteError, "PERMISSIONS");
_logger.Log("INFO", "Save Application", item, ex.Message);
return(item);
}
}
public void Should_create_a_400_response_when_validation_exception_raised(
ValidationFailure validationFailure,
ValidationException validationException,
ValidationExceptionFilter exceptionFilter,
HttpActionExecutedContext actionExecutedContext,
ModelStateDictionary modelStateDictionary,
HttpError httpError)
{
"Given a ValidationExceptionFilter"
.Given(() => exceptionFilter = new ValidationExceptionFilter());
"And a VailidationFailure with property name 'PropertyName' and error 'Error message'"
.And(() => validationFailure = new ValidationFailure("PropertyName", "Error message"));
"And a ValidationException constructed with the VailidationFailure"
.And(() => validationException = new ValidationException(new[] { validationFailure }));
"And a HttpActionExecutedContext containing the ValidationException"
.And(() => actionExecutedContext = new HttpActionExecutedContextBuilder().WithException(validationException));
"When the OnException event is raised with the HttpActionExecutedContext"
.When(() => exceptionFilter.OnException(actionExecutedContext));
"Then the response should have status code 400"
.Then(() => actionExecutedContext.Response.StatusCode.Should().Be(HttpStatusCode.BadRequest));
"And have a HttpError as the content"
.Then(() => (httpError = actionExecutedContext.Response.ContentAs <HttpError>()).Should().NotBeNull());
"With a model error for key 'PropertyName'"
.Then(() => httpError.ReconstructModelState().ContainsKey("PropertyName").Should().BeTrue());
"And the model error should have an error message 'Error message'"
.Then(() => httpError.ReconstructModelState().ErrorMessageForKey("PropertyName").Should().Be("Error message"));
}
public async Task UpdateFundingStructureLastModifiedGuardsAgainstInValidRequests()
{
UpdateFundingStructureLastModifiedRequest request = NewUpdateFundingStructureLastModifiedRequest();
ValidationFailure failureOne = NewValidationFailure();
ValidationFailure failureTwo = NewValidationFailure();
ValidationResult validationResult = NewValidationResult(_ => _.WithValidationFailures(failureOne, failureTwo));
GivenTheValidationResult(request, validationResult);
BadRequestObjectResult actionResult = await WhenTheFundingStructureLastModifiedIsUpdated(request) as BadRequestObjectResult;
SerializableError serializableError = actionResult?.Value as SerializableError;
serializableError
.Should()
.NotBeNull();
serializableError[failureOne.PropertyName]
.Should()
.BeEquivalentTo(new[] { failureOne.ErrorMessage });
serializableError[failureTwo.PropertyName]
.Should()
.BeEquivalentTo(new[] { failureTwo.ErrorMessage });
await AndTheCacheWasNotUpdated();
}
public void SetUp()
{
var services = new RhinoAutoMocker<SampleInputModel>(MockMode.AAA);
var request = services.Get<IFubuRequest>();
_context = new ValidationFailure(ActionCall.For<SampleInputModel>(m => m.Test("Hello")), Notification.Valid(), "Hello");
_policies = new List<IValidationFailurePolicy>();
_handler = new ValidationFailureHandler(_policies, request);
}
public void ValidationExceptions_Initializes_Correctly()
{
var failure = new ValidationFailure
{
ErrorMessage = "some error message",
PropertyName = "property",
};
var exception = new ValidationException(failure);
Assert.AreEqual(1, exception.Descriptions.Count());
Assert.IsTrue(exception.Descriptions.First().ToString().Contains("property"));
exception = new ValidationException(new [] { failure, failure });
Assert.AreEqual(2, exception.Descriptions.Count());
}
/// <summary>
/// Creates an error validation result for this validator.
/// </summary>
/// <param name="context">The validator context</param>
/// <returns>Returns an error validation result.</returns>
protected virtual ValidationFailure CreateValidationError(PropertyValidatorContext context)
{
Func<PropertyValidatorContext, string> errorBuilder = context.Rule.MessageBuilder ?? BuildErrorMessage;
var error = errorBuilder(context);
var failure = new ValidationFailure(context.PropertyName, error, context.PropertyValue);
if (CustomStateProvider != null) {
failure.CustomState = CustomStateProvider(context.Instance);
}
return failure;
}
public object ModelFor(ValidationFailure context)
{
var destinationType = _descriptor.DescribeModelFor(context);
return _modelResolver.Resolve(destinationType, context.InputType(), context.InputModel);
}
public bool Matches(ValidationFailure context)
{
return true;
}
/// <summary>
/// Creates an error validation result for this validator.
/// </summary>
/// <param name="context">The validator context</param>
/// <returns>Returns an error validation result.</returns>
protected virtual ValidationFailure CreateValidationError(PropertyValidatorContext context) {
context.MessageFormatter.AppendAdditionalArguments(
customFormatArgs.Select(func => func(context.Instance)).ToArray()
);
string error = context.MessageFormatter.BuildMessage(errorSource.GetString());
var failure = new ValidationFailure(context.PropertyName, error, errorCode, context.PropertyValue);
if (CustomStateProvider != null) {
failure.CustomState = CustomStateProvider(context.Instance);
}
return failure;
}
public void Handle(ValidationFailure context)
{
throw new System.NotImplementedException();
}
/// <summary>
/// Creates an error validation result for this validator.
/// </summary>
/// <param name="context">The validator context</param>
/// <returns>Returns an error validation result.</returns>
protected virtual ValidationFailure CreateValidationError(PropertyValidatorContext context)
{
Func<PropertyValidatorContext, string> errorBuilder = context.Rule.MessageBuilder ?? BuildErrorMessage;
var error = errorBuilder(context);
var failure = new ValidationFailure(context.PropertyName, error, context.PropertyValue);
failure.FormattedMessageArguments = context.MessageFormatter.AdditionalArguments;
failure.FormattedMessagePlaceholderValues = context.MessageFormatter.PlaceholderValues;
failure.ErrorCode = errorSource.ResourceName;
if (CustomStateProvider != null) {
failure.CustomState = CustomStateProvider(context.Instance);
}
return failure;
}
public bool Matches(ValidationFailure context)
{
throw new System.NotImplementedException();
}
public bool HasFailure(string fieldName, string messageText)
{
var message = new ValidationFailure(fieldName, messageText);
return _list.Contains(message);
}
public ValidationFailure RegisterFailure(string fieldName, string message)
{
var failure = new ValidationFailure(fieldName, message);
if (!_list.Contains(failure))
{
_list.Add(failure);
FailuresFor(failure.FieldName).Add(failure);
}
return failure;
}
/// <summary>
/// Initializes a new instance of the <see cref="ErrorAdapter"/> class.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="failure">The failure.</param>
public ErrorAdapter(object instance, ValidationFailure failure)
{
this.failure = failure;
this.instance = instance;
}
public void Handle(ValidationFailure context)
{
_continuation();
}