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(); }