¿Cómo utilizar el marco del editor de GWT para la validación?

Question

Estoy tratando de integrarme con el nuevo marco GWT Editor de GWT 2.1.0. También quiero agregar mis verificaciones de validación en el marco. Sin embargo, estoy luchando por encontrar un ejemplo decente sobre cómo hacer esto.

Por el momento tengo el siguiente código:

<!DOCTYPE ui:UiBinder SYSTEM "http://dl.google.com/gwt/DTD/xhtml.ent"> 
<ui:UiBinder xmlns:ui="urn:ui:com.google.gwt.uibinder" 
    xmlns:g="urn:import:com.google.gwt.user.client.ui" xmlns:e="urn:import:com.google.gwt.editor.ui.client"> 
    <ui:with type="be.credoc.iov.webapp.client.MessageConstants" 
     field="msg" /> 
    <g:HTMLPanel> 
     <e:ValueBoxEditorDecorator ui:field="personalReference"> 
      <e:valuebox> 
       <g:TextBox /> 
      </e:valuebox> 
     </e:ValueBoxEditorDecorator> 
    </g:HTMLPanel> 
</ui:UiBinder> 

Y para mi editor:

public class GarageEditor extends Composite implements Editor<Garage> { 

    @UiField 
    ValueBoxEditorDecorator<String> personalReference; 

    interface GarageEditorUiBinder extends UiBinder<Widget, GarageEditor> { 
    } 

    private static GarageEditorUiBinder uiBinder = GWT.create(GarageEditorUiBinder.class); 

    public GarageEditor() { 
     initWidget(uiBinder.createAndBindUi(this)); 
    } 

} 

En qué momento tengo que llamar a mi validador y ¿Cómo se integra con ella?

Actualización:

De hecho, estoy buscando una manera de recuperar un mapa con clave como la ruta de propiedad, y como valor el editor. Hay un campo de ruta en un delegado, pero esta no es la ruta dentro del objeto editado, sino la ruta en la clase de editor.

¿Alguien sabe si es posible hacer algo como esto?

Answer 1

Anotar le frijoles con contstrants (véase Person.java)

public class Person { 
    @Size(min = 4) 
    private String name; 
} 

uso del bootstrap de validación estándar para obtener un Validator en el cliente y validar su objeto (vea ValidationView.java)

Validator validator = Validation.buildDefaultValidatorFactory().getValidator(); 
Set<ConstraintViolation<Person>> violations = validator.validate(person); 

Siga este patrón para crear un Validator para los objetos que desea validar en el cliente. (Ver SampleValidatorFactory.java)

public final class SampleValidatorFactory extends AbstractGwtValidatorFactory { 

    /** 
    * Validator marker for the Validation Sample project. Only the classes listed 
    * in the {@link GwtValidation} annotation can be validated. 
    */ 
    @GwtValidation(value = Person.class, 
     groups = {Default.class, ClientGroup.class}) 
    public interface GwtValidator extends Validator { 
    } 

    @Override 
    public AbstractGwtValidator createValidator() { 
    return GWT.create(GwtValidator.class); 
    } 
} 

incluir el módulo de su proveedor de validación. Agregar replace-con la etiqueta en su archivo modle gwt diciendo GWT utilizar el validador que acaba de definir (ver Validation.gwt.xml)

<inherits name="org.hibernate.validator.HibernateValidator" /> 
<replace-with 
    class="com.google.gwt.sample.validation.client.SampleValidatorFactory"> 
    <when-type-is class="javax.validation.ValidatorFactory" /> 
</replace-with> 

Source

Answer 2

La validación aún no existe en GWT, viene en la próxima versión de AFAIK. El soporte actual para la validación en GWT es el lado del servidor JSR-303 y el soporte del lado del cliente JSR-303 estará disponible en breve. Por lo tanto, tendrá que hacer la validación manualmente. Si sigues el modelo MVP, creo que esta lógica de validación viviría en tu Presentador.

Answer 3

Tengo exactamente el mismo problema.

La documentación no es clara al respecto.

Lo que estoy haciendo actualmente es recrear algunos widgets al ampliarlos con el widget que quiero copiar. Después de esto, implemento LeafValueEditor y HasEditorDelegate para anular getValue().

En getValue(), use su validador y llame si es necesario yourDelegate.recordError().

Algo como esto: una cajita entero que compruebe que el valor no es mayor que 10.

public class IntegerField extends ValueBox<Integer> implements LeafValueEditor<Integer>, HasEditorDelegate<Integer> 
{ 
private EditorDelegate<Integer> delegate; 

public IntegerField() 
{ 
    super(Document.get().createTextInputElement(), IntegerRenderer.instance(), IntegerParser.instance()); 

    setStyleName("gwt-TextBox"); 

} 

@Override 
public Integer getValue() 
{ 
    Integer value = super.getValue(); 

    if (value > 10) 
    { 
     delegate.recordError("too big integer !", value, null); 
    } 

    return value; 
} 

@Override 
public void setValue(Integer value) 
{ 
    super.setValue(value); 
} 

@Override 
public void setDelegate(EditorDelegate<Integer> delegate) 
{ 
    this.delegate = delegate; 
} 
} 

El mejor enfoque es simplemente agregar la verificación personalizada a los widgets existentes y no anular ellos, pero yo no lo hacen ¡sé cómo hacerlo!

Answer 4

Es complicado, pero para obtener la ruta de acceso de un Editor, puede implementar HasEditorDelegate (que le dará acceso al delegado) y luego enviar el Delegado a AbstractEditorDelegate, que tiene un método público String getPath().

No creo que sea posible realizar una validación externa; la validación ocurre en el editor en el punto en que se lee un valor del campo (vea ValueBoxEditor - este editor usa getDelegate(). recordError para generar un error). Una opción que sí consideré fue usar el acceso de AbstractEditorDelegate para llamar a flushErrors (List) y crear esa lista de EditorErrors yo mismo. Para hacer eso, necesitas conocer cada una de tus rutas de campo; codificarlos difícilmente es deseable, pero no veo una manera de buscar el campo por la propiedad editada ni nada por el estilo.

Un enfoque alternativo que podría llevar mirando hacia es esta presentación para la validación de ida y vuelta con el RequestFactory:

http://groups.google.com/group/google-web-toolkit-contributors/browse_thread/thread/5be0bda80547ca5a

Answer 5

he hecho algo similar a esto añadiendo una clase DriverWrapper adicional que toma el Controlador y el Validador existentes y agrega un método de descarga que primero delega en la Descarga del Controlador subyacente y luego llama al Validador. Todos los errores devueltos se agregan a los Editores utilizando un nuevo visitante, similar a la forma en que funciona el Flusher existente. Esto significa que los decoradores existentes que muestran los errores junto a los campos continúan funcionando.

/** 
* Wraps a Driver and provides validation using gwt-validation (JSR 303). 
* When calling flush, this will use the provided IValidator to validate the data 
* and use the InvalidConstraintValidationVisitor to add the errors to the delegates. 
* @see InvalidConstraintValidationVisitor 
* @param <T> the data type for the editor 
* @param <D> the driver type 
*/ 
public class ValidationDriverWrapper<T extends IsValidatable<T>, D extends EditorDriver<T>> { 
private IValidator<T> validator; 
private D driver; 

/** 
* Constructor, both parameters are required. 
* @param driver The driver to use to flush the underlying data. 
* @param validator The validator to use to validate the data. 
*/ 
public ValidationDriverWrapper(D driver, IValidator<T> validator) { 
    this.validator = validator; 
    this.driver = driver; 
} 

/** 
* Flushes the underlying Driver and then calls the validation on the underlying Validator, cascading errors as EditorErrors 
* onto the delegates, using InvalidContraintValidationVisitor. 
*/ 
public void flush() 
{ 
    T data = driver.flush(); 
    Set<InvalidConstraint<T>> errors = validator.validate(data); 
    Set<InvalidConstraint<T>> extraErrors = data.validate(); 
    if(extraErrors != null && !extraErrors.isEmpty()) 
    { 
     errors.addAll(extraErrors); 
    } 
    driver.accept(new InvalidConstraintValidationVisitor<T>(errors)); 
}