public FormatErrorMessage ( string name ) : string | ||
name | string | The name to include in the formatted message. |
return | string |
/// <summary> /// Valide les contraintes pour une propriété. /// </summary> /// <param name="value">Valeur de la propriété.</param> /// <param name="checkNullValue">True si la nullité doit être vérifiée.</param> /// <param name="isForceRequirement">Si on force le fait que la propriété est requise ou non.</param> internal void ValidConstraints(object value, bool checkNullValue, bool?isForceRequirement) { bool isRequired = this.IsRequired; if (isForceRequirement.HasValue) { isRequired = isForceRequirement.Value; } if (isRequired && checkNullValue) { RequiredAttribute c = new RequiredAttribute { AllowEmptyStrings = false, ErrorMessageResourceType = typeof(SR), ErrorMessageResourceName = "ConstraintNotNull" }; ExtendedValue extVal = value as ExtendedValue; if (extVal != null) { if (!c.IsValid(extVal.Value) || !c.IsValid(extVal.Metadata)) { throw new ConstraintException(this, c.FormatErrorMessage(PropertyName)); } } else if (!c.IsValid(value)) { throw new ConstraintException(this, c.FormatErrorMessage(PropertyName)); } } this.Domain.CheckValue(value, this); }
/// <summary> /// Determines whether the specified object is valid. /// </summary> /// <param name="validationContext">The validation context.</param> /// <returns>A collection that holds failed-validation information.</returns> public IEnumerable <ValidationResult> Validate(ValidationContext validationContext) { var required = new RequiredAttribute(); switch (Kind) { case CredentialsKind.Default: break; case CredentialsKind.Environment: if (string.IsNullOrEmpty(Environment) == true) { yield return(new ValidationResult(required.FormatErrorMessage(nameof(Environment)))); } break; case CredentialsKind.Impersonate: if (string.IsNullOrEmpty(Environment) == true) { yield return(new ValidationResult(required.FormatErrorMessage(nameof(Environment)))); } if (ImpersonateUserId.HasValue == false) { yield return(new ValidationResult(required.FormatErrorMessage(nameof(ImpersonateUserId)))); } break; default: throw new InvalidOperationException("Unsupported value: " + Kind); } }
protected override ValidationResult IsValid(object value, ValidationContext validationContext) { var property = validationContext.ObjectInstance.GetType().GetProperty(PropertyName); if (property != null) { var propertyValue = property.GetValue(validationContext.ObjectInstance, null); bool isConditionTypeValid = false; switch (ConditionType) { case ConditionType.IsEqualTo: if (propertyValue.IsNotNull()) { isConditionTypeValid = propertyValue.Equals(ConditionValue); } else if (propertyValue.IsNull() && ConditionValue.IsNull()) { isConditionTypeValid = true; } else if (propertyValue.IsNull() && ConditionValue.IsNotNull()) { isConditionTypeValid = false; } break; case ConditionType.IsNotEqualTo: if (propertyValue.IsNotNull()) { isConditionTypeValid = !propertyValue.Equals(ConditionValue); } else if (propertyValue.IsNull() && ConditionValue.IsNull()) { isConditionTypeValid = false; } else if (propertyValue.IsNull() && ConditionValue.IsNotNull()) { isConditionTypeValid = true; } break; } if (isConditionTypeValid) { if (!requiredAttribute.IsValid(value)) { return(new ValidationResult(requiredAttribute.FormatErrorMessage(validationContext.DisplayName))); } } } return(ValidationResult.Success); }
private void SetUpRequiredFieldValidator(RequiredFieldValidator validator, MetaColumn column) { var requiredAttribute = column.Metadata.RequiredAttribute; if (requiredAttribute != null && requiredAttribute.AllowEmptyStrings) { // Dev10 IgnoreModelValidationAttribute(typeof(RequiredAttribute)); } else if (column.IsRequired) { validator.Enabled = true; // Make sure the attribute doesn't get validated a second time by the DynamicValidator IgnoreModelValidationAttribute(typeof(RequiredAttribute)); if (String.IsNullOrEmpty(validator.ErrorMessage)) { string columnErrorMessage = column.RequiredErrorMessage; if (String.IsNullOrEmpty(columnErrorMessage)) { // generate default error message validator.ErrorMessage = HttpUtility.HtmlEncode(s_defaultRequiredAttribute.FormatErrorMessage(column.DisplayName)); } else { validator.ErrorMessage = HttpUtility.HtmlEncode(columnErrorMessage); } } } }
private void SetUpRequiredFieldValidator(RequiredFieldValidator validator, MetaColumn column) { var requiredAttribute = column.Metadata.RequiredAttribute; if (requiredAttribute != null && requiredAttribute.AllowEmptyStrings) { // Dev10 Bug 749744 // If somone explicitly set AllowEmptyStrings = true then we assume that they want to // allow empty strings to go into a database even if the column is marked as required. // Since ASP.NET validators always get an empty string, this essential turns of // required field validation. IgnoreModelValidationAttribute(typeof(RequiredAttribute)); } else if (column.IsRequired) { validator.Enabled = true; // Make sure the attribute doesn't get validated a second time by the DynamicValidator IgnoreModelValidationAttribute(typeof(RequiredAttribute)); if (String.IsNullOrEmpty(validator.ErrorMessage)) { string columnErrorMessage = column.RequiredErrorMessage; if (String.IsNullOrEmpty(columnErrorMessage)) { // generate default error message validator.ErrorMessage = HttpUtility.HtmlEncode(s_defaultRequiredAttribute.FormatErrorMessage(column.DisplayName)); } else { validator.ErrorMessage = HttpUtility.HtmlEncode(columnErrorMessage); } } } }
public void Entity_EndEditValidatesRequiredProperties() { // Start with an entity that doesn't have its required properties // satisfied (Name is required) Cities.City city = new Cities.City(); IEditableObject editableCity = (IEditableObject)city; RequiredAttribute template = new RequiredAttribute(); string expectedMemberName = "CityName"; string expectedError = template.FormatErrorMessage(expectedMemberName); // Begin the edit transaction editableCity.BeginEdit(); #if SILVERLIGHT string expectedMember = "Name"; // End the edit transaction, which performs property and entity-level validation editableCity.EndEdit(); Assert.AreEqual <int>(1, city.ValidationErrors.Count, "After EndEdit"); Assert.AreEqual <int>(1, city.ValidationErrors.Single().MemberNames.Count(), "MemberNames count after EndEdit"); Assert.AreEqual <string>(expectedMember, city.ValidationErrors.Single().MemberNames.Single(), "Member name after EndEdit"); Assert.AreEqual <string>(expectedError, city.ValidationErrors.Single().ErrorMessage, "ErrorMessage after EndEdit"); #else ExceptionHelper.ExpectException <ValidationException>(delegate { ((IEditableObject)city).EndEdit(); }, expectedError); #endif }
public override string FormatErrorMessage(string name) { if (!String.IsNullOrEmpty(this.ErrorMessageString)) { _innerAttribute.ErrorMessage = this.ErrorMessageString; } return(_innerAttribute.FormatErrorMessage(name)); }
public override string FormatErrorMessage(string name) { if (!String.IsNullOrEmpty(this.ErrorMessageString)) { return(String.Format(this.ErrorMessageString, name, ButtonName)); } return(_innerAttribute.FormatErrorMessage(name)); }
/// <summary> /// /// </summary> /// <param name="name"></param> /// <returns></returns> public override string FormatErrorMessage(string name) { if (!String.IsNullOrEmpty(this.ErrorMessageString)) { required.ErrorMessage = this.ErrorMessageString; } return(required.FormatErrorMessage(name)); }
public void RequiredOption_ErrorMessage(string template, string valueName) { var required = new RequiredAttribute(); var expected = required.FormatErrorMessage(valueName); var app = new CommandLineApplication(); app.Option(template, string.Empty, CommandOptionType.SingleValue).IsRequired(); var validation = app.GetValidationResult(); Assert.Equal(expected, validation.ErrorMessage); }
public void RequiredArgument_ErrorMessage() { var required = new RequiredAttribute(); var expected = required.FormatErrorMessage("Arg"); var app = new CommandLineApplication(); app.Argument("Arg", string.Empty).IsRequired(); var validation = app.GetValidationResult(); Assert.Equal(expected, validation.ErrorMessage); }
public void ValuesSet() { // Arrange ModelMetadata metadata = _metadataProvider.GetMetadataForProperty(() => 15, typeof(string), "Length"); var attribute = new RequiredAttribute(); // Act var validator = new DataAnnotationsModelValidator(metadata, _noValidatorProviders, attribute); // Assert Assert.Same(attribute, validator.Attribute); Assert.Equal(attribute.FormatErrorMessage("Length"), validator.ErrorMessage); }
public void ValuesSet() { // Arrange ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForProperty(() => 15, typeof(string), "Length"); ControllerContext context = new ControllerContext(); RequiredAttribute attribute = new RequiredAttribute(); // Act DataAnnotationsModelValidator validator = new DataAnnotationsModelValidator(metadata, context, attribute); // Assert Assert.Same(attribute, validator.Attribute); Assert.Equal(attribute.FormatErrorMessage("Length"), validator.ErrorMessage); }
/// <summary> /// Main process of model binding /// </summary> /// <param name="controllerContext"></param> /// <param name="bindingContext"></param> /// <returns></returns> public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) { object result = null; //handle pemisah angka desimal dan ribuan untuk bilangan if (bindingContext.ModelType == typeof(double) || bindingContext.ModelType == typeof(double?) || bindingContext.ModelType == typeof(decimal) || bindingContext.ModelType == typeof(decimal?)) { string modelName = bindingContext.ModelName; var valueResult = bindingContext.ValueProvider.GetValue(modelName); string attemptedValue = valueResult.AttemptedValue; bindingContext.ModelState.SetModelValue(modelName, valueResult); // Depending on cultureinfo the NumberDecimalSeparator can be "," or "." // Both "." and "," should be accepted, but aren't. string wantedSeperator = NumberFormatInfo.CurrentInfo.NumberDecimalSeparator; string alternateSeperator = (wantedSeperator == "," ? "." : ","); // ReSharper disable StringIndexOfIsCultureSpecific.1 if (attemptedValue.IndexOf(wantedSeperator) == -1 && attemptedValue.IndexOf(alternateSeperator) != -1) { attemptedValue = attemptedValue.Replace(alternateSeperator, wantedSeperator); } try { if (bindingContext.ModelType == typeof(Double) || bindingContext.ModelType == typeof(double?)) { result = double.Parse(attemptedValue, NumberStyles.Any); } if (bindingContext.ModelType == typeof(Decimal) || bindingContext.ModelType == typeof(decimal?)) { result = decimal.Parse(attemptedValue, NumberStyles.Any); } } catch (FormatException) { var requiredAttribute = new RequiredAttribute(); //anggap bukan error jika model adalah nullable if (string.IsNullOrEmpty(attemptedValue) && bindingContext.ModelType != typeof(decimal?) && bindingContext.ModelType != typeof(double?)) { bindingContext.ModelState.AddModelError(modelName, requiredAttribute.FormatErrorMessage(bindingContext.ModelMetadata.DisplayName)); } } } return(result); }
/// <summary> /// Checks whether the value is null or not. /// </summary> /// <param name="variable">The variable in context.</param> /// <param name="getVariableName">The name of the variable that should be populated in the error context.</param> /// <param name="actionContext">Current action context.</param> /// <param name="modelState">Current model object.</param> /// <returns>The status of the operation.</returns> public static bool Required(string variable, Expression <Func <string, string> > getVariableName, HttpActionContext actionContext, ModelStateDictionary modelState) { var variableName = ((MemberExpression)getVariableName.Body).Member.Name; var attr = new RequiredAttribute(); if (!attr.IsValid(variable) || variable.Equals("null", StringComparison.OrdinalIgnoreCase)) { modelState.AddModelError(attr.ToString(), attr.FormatErrorMessage(variableName)); AddErrorToResponse(actionContext, modelState); return(false); } return(true); }
public async Task BindModelAsync_EnforcesTopLevelRequiredAndLogsSuccessfully_WithEmptyPrefix( RequiredAttribute attribute, ParameterDescriptor parameterDescriptor, ModelMetadata metadata) { // Arrange var expectedKey = string.Empty; var expectedFieldName = metadata.Name ?? nameof(Person); var actionContext = GetControllerContext(); var validator = new DataAnnotationsModelValidator( new ValidationAttributeAdapterProvider(), attribute, stringLocalizer: null); var sink = new TestSink(); var loggerFactory = new TestLoggerFactory(sink, enabled: true); var parameterBinder = CreateParameterBinder(metadata, validator, loggerFactory: loggerFactory); var modelBindingResult = ModelBindingResult.Success(null); // Act var result = await parameterBinder.BindModelAsync( actionContext, CreateMockModelBinder(modelBindingResult), CreateMockValueProvider(), parameterDescriptor, metadata, "ignoredvalue"); // Assert Assert.False(actionContext.ModelState.IsValid); var modelState = Assert.Single(actionContext.ModelState); Assert.Equal(expectedKey, modelState.Key); var error = Assert.Single(modelState.Value.Errors); Assert.Equal(attribute.FormatErrorMessage(expectedFieldName), error.ErrorMessage); Assert.Equal(4, sink.Writes.Count()); }
private static string WriteExtenders(PropertyInfo p, out bool isValidatable) { isValidatable = false; StringBuilder sb = new StringBuilder(); sb.Append(".extend({ editState : false, disableValidation : false, empty : true })"); RequiredAttribute requiredAttribute = p.GetCustomAttribute <RequiredAttribute>(); if (requiredAttribute != null) { sb.Append($".extend({{ required: {{ message: \"{requiredAttribute.FormatErrorMessage(p.Name)}\", onlyIf: function() {{ return ko.utils.isPropertyValidatable(self, \"{ p.Name}\"); }} }} }})"); isValidatable = true; } MinLengthAttribute minLengthAttribute = p.GetCustomAttribute <MinLengthAttribute>(); if (minLengthAttribute != null) { sb.Append(string.Format(".extend({ minLength: { message: \"{0}\", params: {1}, onlyIf: function() { return ko.utils.isPropertyValidatable(self, \"{2}\"); } } })", minLengthAttribute.FormatErrorMessage(p.Name), minLengthAttribute.Length, p.Name)); isValidatable = true; } MaxLengthAttribute maxLengthAttribute = p.GetCustomAttribute <MaxLengthAttribute>(); if (maxLengthAttribute != null) { sb.Append(string.Format(".extend({ maxLength: { message: \"{0}\", params: {1}, onlyIf: function() { return ko.utils.isPropertyValidatable(self, \"{2}\"); } } })", maxLengthAttribute.FormatErrorMessage(p.Name), maxLengthAttribute.Length, p.Name)); isValidatable = true; } RegularExpressionAttribute regularExpressionAttribute = p.GetCustomAttribute <RegularExpressionAttribute>(); if (regularExpressionAttribute != null) { sb.Append(string.Format(".extend({ pattern: { message: \"{0}\", params: /{1}/, onlyIf: function() { return ko.utils.isPropertyValidatable(self, \"{2}\"); } } })", regularExpressionAttribute.FormatErrorMessage(p.Name), regularExpressionAttribute.Pattern, p.Name)); isValidatable = true; } UrlAttribute urlAttribute = p.GetCustomAttribute <UrlAttribute>(); if (urlAttribute != null) { sb.Append(string.Format(".extend({ pattern: { message: \"{0}\", params: /{1}/, onlyIf: function() { return ko.utils.isPropertyValidatable(self, \"{2}\"); } } })", urlAttribute.FormatErrorMessage(p.Name), urlAttribute, p.Name)); isValidatable = true; } DateAttribute dateAttribute = p.GetCustomAttribute <DateAttribute>(); if (dateAttribute != null) { sb.Append(string.Format(".extend({ date: { message: \"{0}\", onlyIf: function() { return ko.utils.isPropertyValidatable(self, \"{1}\"); } } })", dateAttribute.FormatErrorMessage(p.Name), p.Name)); isValidatable = true; } NumericAttribute numericAttribute = p.GetCustomAttribute <NumericAttribute>(); if (numericAttribute != null) { sb.Append( string.Format(".extend({ number: { message: \"{0}\", onlyIf: function() { return ko.utils.isPropertyValidatable(self, \"{1}\"); } } }).extend({ numeric: {2} })", numericAttribute.FormatErrorMessage(p.Name), p.Name, numericAttribute.Precision)); isValidatable = true; } EmailAttribute emailAttribute = p.GetCustomAttribute <EmailAttribute>(); if (emailAttribute != null) { sb.Append(string.Format(".extend({ email: { message: \"{0}\", onlyIf: function() { return ko.utils.isPropertyValidatable(self, \"{1}\"); } } })", emailAttribute.FormatErrorMessage(p.Name), p.Name)); isValidatable = true; } DigitsAttribute digitsAttribute = p.GetCustomAttribute <DigitsAttribute>(); if (digitsAttribute != null) { sb.Append(string.Format(".extend({ digit: { message: \"{0}\", onlyIf: function() { return ko.utils.isPropertyValidatable(self, \"{1}\"); } } }).extend({ numeric: 0 })", digitsAttribute.FormatErrorMessage(p.Name), p.Name)); isValidatable = true; } MinAttribute minAttribute = p.GetCustomAttribute <MinAttribute>(); if (minAttribute != null) { sb.Append(string.Format(".extend({ min: { message: \"{0}\", params: {1}, onlyIf: function() { return ko.utils.isPropertyValidatable(self, \"{2}\"); } } })", minAttribute.FormatErrorMessage(p.Name), minAttribute.Min, p.Name)); isValidatable = true; } MaxAttribute maxAttribute = p.GetCustomAttribute <MaxAttribute>(); if (maxAttribute != null) { sb.Append(string.Format(".extend({ max: { message: \"{0}\", params: {1}, onlyIf: function() { return ko.utils.isPropertyValidatable(self, \"{2}\"); } } })", maxAttribute.FormatErrorMessage(p.Name), maxAttribute.Max, p.Name)); isValidatable = true; } EqualToAttribute equalToAttribute = p.GetCustomAttribute <EqualToAttribute>(); if (equalToAttribute != null) { sb.Append(string.Format(".extend({ equal: { message: \"{0}\", params: {1}, onlyIf: function() { return ko.utils.isPropertyValidatable(self, \"{2}\"); } } })", equalToAttribute.FormatErrorMessage(p.Name), equalToAttribute.OtherProperty, p.Name)); isValidatable = true; } CompareAttribute compareAttribute = p.GetCustomAttribute <CompareAttribute>(); if (compareAttribute != null) { sb.Append(string.Format(".extend({ equal: { message: \"{0}\", params: \"{1}\", onlyIf: function() { return ko.utils.isPropertyValidatable(self, \"{2}\"); } } })", compareAttribute.FormatErrorMessage(p.Name), compareAttribute.OtherProperty, p.Name)); isValidatable = true; } FormatterAttribute formatterAttribute = p.GetCustomAttribute <FormatterAttribute>(); if (formatterAttribute != null) { sb.Append(string.Format(".formatted({0}, {1})", formatterAttribute.Formatter, JsonConvert.SerializeObject(formatterAttribute.Arguments))); } return(sb.ToString()); }
public static string GetRequiredErrorMessage(string field) { var attr = new RequiredAttribute(); return(attr.FormatErrorMessage(field)); }
/// <summary> /// Applies formatting to an error message, based on the data field where the error occurred. /// </summary> /// <param name="name">The name of the validated property.</param> public override string FormatErrorMessage(string name) { EnsureErrorMessage(); UpdateInnerValidator(); return(reqValidator.FormatErrorMessage(name)); }
public void DefaultErrorMessage() { RequiredAttribute required = new RequiredAttribute(); Assert.AreEqual(String.Format(CultureInfo.CurrentCulture, Resources.DataAnnotationsResources.RequiredAttribute_ValidationError, "SOME_NAME"), required.FormatErrorMessage("SOME_NAME")); }
public void DefaultErrorMessage() { RequiredAttribute required = new RequiredAttribute(); Assert.AreEqual(String.Format(CultureInfo.CurrentCulture, Resources.DataAnnotationsResources.RequiredAttribute_ValidationError, "SOME_NAME"), required.FormatErrorMessage("SOME_NAME")); }