comparación de fechas DataAnnotations Validación asp.net mvc

Question

Digamos que tengo un StartDate y un EndDate y Wnt para comprobar si el EndDate no más de 3 meses de diferencia entre la fecha de inicio

public class DateCompare : ValidationAttribute 
{ 
    public String StartDate { get; set; } 
    public String EndDate { get; set; } 

    //Constructor to take in the property names that are supposed to be checked 
    public DateCompare(String startDate, String endDate) 
    { 
     StartDate = startDate; 
     EndDate = endDate; 
    } 

    public override bool IsValid(object value) 
    { 
     var str = value.ToString(); 
     if (string.IsNullOrEmpty(str)) 
      return true; 

     DateTime theEndDate = DateTime.ParseExact(EndDate, "yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture); 
     DateTime theStartDate = DateTime.ParseExact(StartDate, "yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture).AddMonths(3); 
     return (DateTime.Compare(theStartDate, theEndDate) > 0); 
    } 
} 

y me gustaría para implementar esto en mi validación

[DateCompare ("StartDate", "EndDate", ErrorMessage = "El trato sólo puede ser de 3 meses de duración!")]

sé que sale un error aquí ... pero ¿cómo puedo hacer este tipo de validación de reglas comerciales en asp.net mvc

Answer 1

Solo he descubierto cómo hacerlo a nivel de clase pero no a nivel de propiedad. Si crea una aplicación MVC, el modelo de cuenta muestra el enfoque que se ilustra a continuación.

Clase:

[PropertiesMustMatch("Password", 
      "ConfirmPassword", ErrorMessage = 
      "Password and confirmation password 
      do not match.")] 
       public class RegisterModel 
       { 

        [Required(ErrorMessage = "Required")] 
        [DataType(DataType.EmailAddress)] 
        [DisplayName("Your Email")] 
        public string Email { get; set; }    

        [Required(ErrorMessage = "Required")] 
        [ValidatePasswordLength] 
        [DataType(DataType.Password)] 
        [DisplayName("Password")] 
        public string Password { get; set; } 

        [Required(ErrorMessage = "Required")] 
        [DataType(DataType.Password)] 
        [DisplayName("Re-enter password")] 
        public string ConfirmPassword { get; set; }     
       } 

Validación de Método:

[AttributeUsage(AttributeTargets.Class, AllowMultiple = true, Inherited = true)] 
    public sealed class PropertiesMustMatchAttribute : ValidationAttribute 
    { 
     private const string _defaultErrorMessage = "'{0}' and '{1}' do not match."; 

     private readonly object _typeId = new object(); 

     public PropertiesMustMatchAttribute(string originalProperty, string confirmProperty) 
      : base(_defaultErrorMessage) 
     { 
      OriginalProperty = originalProperty; 
      ConfirmProperty = confirmProperty; 
     } 

     public string ConfirmProperty 
     { 
      get; 
      private set; 
     } 

     public string OriginalProperty 
     { 
      get; 
      private set; 
     } 

     public override object TypeId 
     { 
      get 
      { 
       return _typeId; 
      } 
     } 

     public override string FormatErrorMessage(string name) 
     { 
      return String.Format(CultureInfo.CurrentUICulture, ErrorMessageString, 
       OriginalProperty, ConfirmProperty); 
     } 

     public override bool IsValid(object value) 
     { 
      PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(value); 
      object originalValue = properties.Find(OriginalProperty, true /* ignoreCase */).GetValue(value); 
      object confirmValue = properties.Find(ConfirmProperty, true /* ignoreCase */).GetValue(value); 
      return Object.Equals(originalValue, confirmValue); 
     } 
} 

Answer 2

El Atributo

public class CompareValidatorAttribute : ValidationAttribute, IInstanceValidationAttribute 
{ 
    public CompareValidatorAttribute(string prefix, string propertyName) { 
     Check.CheckNullArgument("propertyName", propertyName); 

     this.propertyName = propertyName; 
     this.prefix = prefix; 
    } 

    string propertyName, prefix; 

    public string PropertyName 
    { 
     get { return propertyName; } 
    } 

    public string Prefix 
    { 
     get { return prefix; } 
    } 

    #region IInstanceValidationAttribute Members 

    public bool IsValid(object instance, object value) 
    { 
     var property = instance.GetType().GetProperty(propertyName); 

     var targetValue = property.GetValue(instance, null); 
     if ((targetValue == null && value == null) || (targetValue != null && targetValue.Equals(value))) 
      return true; 

     return false; 
    } 

    #endregion 

    public override bool IsValid(object value) 
    { 
     throw new NotImplementedException(); 
    } 
} 

La Interfaz

public interface IInstanceValidationAttribute 
{ 
    bool IsValid(object instance, object value); 
} 

El Validador

public class CompareValidator : DataAnnotationsModelValidator<CompareValidatorAttribute> 
{ 
    public CompareValidator(ModelMetadata metadata, ControllerContext context, CompareValidatorAttribute attribute) 
     : base(metadata, context, attribute) 
    { 
    } 

    public override IEnumerable<ModelValidationResult> Validate(object container) 
    { 
     if (!(Attribute as IInstanceValidationAttribute).IsValid(container, Metadata.Model)) 
      yield return (new ModelValidationResult 
      { 
       MemberName = Metadata.PropertyName, 
       Message = Attribute.ErrorMessage 
      }); 
    } 

    public override IEnumerable<ModelClientValidationRule> GetClientValidationRules() 
    { 
     var rule = new ModelClientValidationRule() { ErrorMessage = Attribute.ErrorMessage, ValidationType = "equalTo" }; 
     rule.ValidationParameters.Add("equalTo", "#" + (!string.IsNullOrEmpty(Attribute.Prefix) ? Attribute.Prefix + "_" : string.Empty)+ Attribute.PropertyName); 

     return new[] { rule }; 
    } 
} 

Puedes verlo:

DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(CompareValidatorAttribute), typeof(CompareValidator)); 

Answer 3

Gracias por la información. Me quedé rascándome la cabeza cuando quise vincular el mensaje de validación a una propiedad. Si se cambia la línea

[AttributeUsage(AttributeTargets.Class)] 

a ...

[AttributeUsage(AttributeTargets.Property)] 

puede mover la comparación de una propiedad específica. Gracias por la info! Mucha ayuda ya que mi cliente aún se ejecuta en 3.5 sp1. cara triste

Answer 4

1. fechas

Entidad:

[MetadataType(typeof(MyEntity_Validation))] 
public partial class MyEntity 
{ 
} 
public class MyEntity_Validation 
{ 
    [Required(ErrorMessage="'Date from' is required")] 
    public DateTime DateFrom { get; set; } 

    [CompareDatesValidatorAttribute("DateFrom")] 
    public DateTime DateTo { get; set; } 
} 

Atributo:

public sealed class CompareDatesValidatorAttribute : ValidationAttribute 
{ 
    private string _dateToCompare; 
    private const string _errorMessage = "'{0}' must be greater or equal'{1}'"; 

    public CompareDatesValidatorAttribute(string dateToCompare) 
     : base(_errorMessage) 
    { 
     _dateToCompare = dateToCompare; 
    } 

    public override string FormatErrorMessage(string name) 
    { 
     return string.Format(_errorMessage, name, _dateToCompare); 
    } 

    protected override ValidationResult IsValid(object value, ValidationContext validationContext) 
    { 
     var dateToCompare = validationContext.ObjectType.GetProperty(_dateToCompare); 
     var dateToCompareValue = dateToCompare.GetValue(validationContext.ObjectInstance, null); 
     if (dateToCompareValue != null && value != null && (DateTime)value < (DateTime)dateToCompareValue) 
     { 
      return new ValidationResult(FormatErrorMessage(validationContext.DisplayName)); 
     } 
     return null; 
    } 
} 

2.Contraseña

Entidad:

public string Password { get; set; } 

    [Compare("Password", ErrorMessage = "ConfirmPassword must match Password")] 
    public string ConfirmPassword { get; set; } 

espero que ayude

Answer 5

Es una respuesta tardía pero quería compartirlo para que otros Outhere. Así es como yo lo he hecho para que todo se valida mediante la validación del cliente discreta:

1. crear una clase de atributo:
   

   public class DateCompareValidationAttribute : ValidationAttribute, IClientValidatable 
   { 
   
       public enum CompareType 
       { 
        GreatherThen, 
        GreatherThenOrEqualTo, 
        EqualTo, 
        LessThenOrEqualTo, 
        LessThen 
       } 
   
   
   
   
       private CompareType _compareType; 
       private DateTime _fromDate; 
       private DateTime _toDate; 
   
       private string _propertyNameToCompare; 
   
       public DateCompareValidationAttribute(CompareType compareType, string message, string compareWith = "") 
   { 
       _compareType = compareType; 
       _propertyNameToCompare = compareWith; 
       ErrorMessage = message; 
   } 
   
   
   #region IClientValidatable Members 
   /// <summary> 
   /// Generates client validation rules 
   /// </summary> 
   public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context) 
   { 
       ValidateAndGetCompareToProperty(metadata.ContainerType); 
       var rule = new ModelClientValidationRule(); 
   
       rule.ErrorMessage = ErrorMessage; 
       rule.ValidationParameters.Add("comparetodate", _propertyNameToCompare); 
       rule.ValidationParameters.Add("comparetype", _compareType); 
       rule.ValidationType = "compare"; 
   
       yield return rule; 
   } 
   
   #endregion 
   
   
   protected override ValidationResult IsValid(object value, ValidationContext validationContext) 
   { 
       // Have to override IsValid method. If you have any logic for server site validation, put it here. 
       return ValidationResult.Success; 
   
   } 
   
   /// <summary> 
   /// verifies that the compare-to property exists and of the right types and returnes this property 
   /// </summary> 
   /// <param name="containerType">Type of the container object</param> 
   /// <returns></returns> 
   private PropertyInfo ValidateAndGetCompareToProperty(Type containerType) 
   { 
       var compareToProperty = containerType.GetProperty(_propertyNameToCompare); 
       if (compareToProperty == null) 
       { 
        string msg = string.Format("Invalid design time usage of {0}. Property {1} is not found in the {2}", this.GetType().FullName, _propertyNameToCompare, containerType.FullName); 
        throw new ArgumentException(msg); 
       } 
       if (compareToProperty.PropertyType != typeof(DateTime) && compareToProperty.PropertyType != typeof(DateTime?)) 
       { 
        string msg = string.Format("Invalid design time usage of {0}. The type of property {1} of the {2} is not DateType", this.GetType().FullName, _propertyNameToCompare, containerType.FullName); 
        throw new ArgumentException(msg); 
       } 
   
       return compareToProperty; 
   } 
   } 
   

   Nota: si desea validar la longitud de tiempo, añadir otro parámetro a la constractor y el cambio enumerador para este tipo específico de comparsion
   

2. Añadir los atributos para el campo como folows:
   [DateCompareValidation(DateCompareValidationAttribute.CompareType.GreatherThenOrEqualTo, "This Date must be on or after another date", compareWith: "AnotherDate")]

3. Tome nota de cómo se ha modificado su html generado. Debe incluir su mensaje de validación, nombre de campo para la fecha de comparación, etc. Los parms generados comenzarían con "data-val-compare". Usted definió esta "comparación" cuando establece ValidationType = "compare" en el método GetClientValidationRules.

4. Ahora necesita el código JavaScript correspondiente: para agregar un adaptador de validación y un método de validación. Usé un método anónimo aquí, pero no es necesario. Recomiendo colocar este código en un archivo javascript por separado para que este archivo junto con su clase de atributo se convierta en un control y se pueda usar en cualquier lugar.
   

$ .validator.unobtrusive.adapters.add ( 'comparar', [ 'comparetodate', 'comparetype'], función (opciones) { options.rules [ 'comparar' ] = options.params; options.messages ['compare'] = options.message; } );

$.validator.addMethod("compare", function (value, element, parameters) { 
    // value is the actuall value entered 
    // element is the field itself, that contain the the value (in case the value is not enough) 

    var errMsg = ""; 
    // validate parameters to make sure everyting the usage is right 
    if (parameters.comparetodate == undefined) { 
     errMsg = "Compare validation cannot be executed: comparetodate parameter not found"; 
     alert(errMsg); 
     return false; 
    } 
    if (parameters.comparetype == undefined) { 
     errMsg = "Compare validation cannot be executed: comparetype parameter not found"; 
     alert(errMsg); 
     return false; 
    } 


    var compareToDateElement = $('#' + parameters.comparetodate).get(); 
    if (compareToDateElement.length == 0) { 
     errMsg = "Compare validation cannot be executed: Element to compare " + parameters.comparetodate + " not found"; 
     alert(errMsg); 
     return false; 
    } 
    if (compareToDateElement.length > 1) { 
     errMsg = "Compare validation cannot be executed: more then one Element to compare with id " + parameters.comparetodate + " found"; 
     alert(errMsg); 
     return false; 
    } 
    //debugger; 

    if (value && !isNaN(Date.parse(value))) { 
     //validate only the value contains a valid date. For invalid dates and blanks non-custom validation should be used  
     //get date to compare 
     var compareToDateValue = $('#' + parameters.comparetodate).val(); 
     if (compareToDateValue && !isNaN(Date.parse(compareToDateValue))) { 
      //if date to compare is not a valid date, don't validate this 
      switch (parameters.comparetype) { 
       case 'GreatherThen': 
        return new Date(value) > new Date(compareToDateValue); 
       case 'GreatherThenOrEqualTo': 
        return new Date(value) >= new Date(compareToDateValue); 
       case 'EqualTo': 
        return new Date(value) == new Date(compareToDateValue); 
       case 'LessThenOrEqualTo': 
        return new Date(value) <= new Date(compareToDateValue); 
       case 'LessThen': 
        return new Date(value) < new Date(compareToDateValue); 
       default: 
        { 
         errMsg = "Compare validation cannot be executed: '" + parameters.comparetype + "' is invalid for comparetype parameter"; 
         alert(errMsg); 
         return false; 
        } 
      } 
      return true; 
     } 
     else 
      return true; 

    } 
    else 
     return true; 
}); 

Este se encarga solamente de la validación del lado del cliente discreta. Si necesita el lado del servidor, debe tener cierta lógica en la anulación del método isValid. Además, puede usar Reflection para generar un mensaje de error usando atributos de visualización, etc. y hacer que el argumento del mensaje sea opcional.