Tengo un viewmodel para un formulario que estoy tratando de agregar la validación para el uso de octavos de final de la validación.

fromDate: ko.observable(
            moment().subtract('days', 1).startOf('day').format(dateFormat)
          ),
toDate: ko.observable(
            moment().startOf('day').format(dateFormat)
        ),

Necesito para asegurarse de que la fecha es menor que el hasta la fecha. Me parece que no puede tener cualquier forma de validador personalizado para recoger la referencia a la segunda observable. Necesito algo a lo largo de las líneas de:

toDate: ko.observable(moment().startOf('day').format(dateFormat)).extend({
          validation: {
            validator: function (val, someOtherVal) {
                return moment(val) >= moment(someOtherVal);
            },
            message: 'Must be greater or equal to From Date',
            params: viewModel.fromDate()
          }
        }),

Alguna idea?

Actualización

Estoy seguro de que yo ya había probado este, pero siguiendo el método de extensión en el onload de la función obras.

$(function () {
    ko.validation.configure({ decorateElement: true });

    viewModel.toDate.extend({
    validation: {
            validator: function (val, someOtherVal) {
                return moment(val) >= moment(viewModel.fromDate());
            },
            message: 'To date must be greater than from date',
        }
    });

    ko.applyBindings(viewModel);
});

OriginalEl autor Matt | 2013-01-29

4 Comentarios

  1. 6

    de octavos de final de la validación de las reglas fundamentales no son capaces de manejar las características observables como parámetros para las validaciones. Pero ya hay un empuje de solicitud que debe arreglar eso: https://github.com/ericmbarnard/Knockout-Validation/pull/217

    Por lo tanto, usted tiene que utilizar una función personalizada para que. Usted debe insertar el parámetro como una función (por omitir los paréntesis). Que permitirá a los octavos de final de la validación para reaccionar a los cambios en el param.

    function ViewModel() {
        var self = this; //capture this to be able to reference properties
    
        self.fromDate = ko.observable(
            moment().subtract('days', 1).startOf('day').format(dateFormat)
        );
        self.toDate = ko.observable(
            moment().startOf('day').format(dateFormat)
        ).extend({
          validation: {
            validator: function (val, someOtherVal) {
                return moment(val) >= moment(someOtherVal());
            },
            message: 'Must be greater or equal to From Date',
            params: self.fromDate
          }
        }),
    }
    params: auto.fromDate es la magia. Gracias por esto!

    OriginalEl autor delixfe

  2. 2

    Mirando el documentación para él, esto se parece a la forma en que usted podría hacer:

    ko.validation.rules['greaterThan'] = {
        validator: function (val, otherVal) {
            return val > otherVal;
        },
        message: 'The field must be greater than {0}'
    };
    
    ko.validation.registerExtenders();
    
    fromDate: ko.observable(
                moment().subtract('days', 1).startOf('day').format(dateFormat)
              ),
    toDate: ko.observable(
                moment().startOf('day').format(dateFormat)
            ).extend({ greaterThan: fromDate() });

    Es probado, y no sé si usted desea pasar en fromDate(), o fromDate y, a continuación, en el validador uso otherVal().

    Ya ha probado que, todavía viene con ‘Uncaught TypeError: No se puede llamar el método ‘fromDate’ undefined’
    ¿Tiene usted una referencia dentro de la viewmodel (var = auto), y tratar de mayorque: auto.fromDate() ?
    Sí, parece que los métodos de extensión no puede hacer referencia al modelo de vista si se declaran dentro de ella. El registro una vez que hay una instancia de la vista de modelo parece funcionar. tenga en cuenta que estaba usando el var vm ={} la sintaxis de la función basada en la sintaxis, esto puede no ser el caso, entonces.
    Me imagino que es porque en el momento en que se fueron sumando al extender el método, el viewmodel no había terminado de inicialización, y por lo tanto no existen, por lo que está definido en su método de validación.
    La última línea en la respuesta de Pablo debe verse así: ).extend({ mayorque: este.fromDate }); es decir, el parámetro tiene que ser superado sin paréntesis. y la tercera línea debe verse como: retorno val > otherVal(); — otherVal con paréntesis. De esa manera funciona.

    OriginalEl autor Paul Manzotti

  3. 0

    Este es un poco tarde a la fiesta, pero cuando voy a google para «knockoutjs campo de la contraseña coincide con» este es el top hit.

    Yo quería un combinador sin el uso de la validación de la extensión, porque no tenía necesidad de todas las ofrendas de ese paquete.

    He encontrado un ordenado, knockoutjs truco para la comprobación de dos o más campos, uno contra el otro usando un extensor. Que es, a suscribir el original del campo para el segundo campo en un extensor para desencadenar una valueHasMutated() en contra de la segunda campo cuando el original se actualiza.

      ko.extenders.match = function(target, match_original) {
      target.match_ok = ko.observable();
      function copy(value) {
        target.match_ok(value == match_original());
      }
      function original(value) {
        target.valueHasMutated();
      }
      copy(target());
      target.subscribe(copy);
      match_original.subscribe(original);
      return target;
    };

    Aquí es un jsfiddle para ilustrar mejor la funcionalidad
    https://jsfiddle.net/8nugva9f/13/

    HTH

    OriginalEl autor Bob Smith

  4. -1
    this.fromDate= ko.observable(null).extend({
            date: true,
    
        });
    
    this.toDate = ko.observable(null).extend({
            date: true,
            min: this.fromDate,
    
        });

    Probar esta.

    OriginalEl autor PriyankaLT

Dejar respuesta

Please enter your comment!
Please enter your name here