java - validacion - ¿Cómo utilizar el marco del editor GWT para la validación?

validar formulario jquery

Question

Estoy tratando de integrarme con el nuevo framework GWT Editor de GWT 2.1.0. También quiero agregar mis verificaciones de validación en el marco. Sin embargo, estoy luchando para encontrar un ejemplo decente de 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é punto debo llamar a mi validador y cómo me integro con él?

Actualizar:

Realmente estoy buscando una manera de recuperar un mapa con como clave la ruta de la 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 del editor.

¿Alguien sabe si es posible hacer algo como esto?

Answer 1

Anote sus frijoles con contranes (vea Person.java )

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

Utilice la rutina de arranque 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 validador 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);
}
}

Incluya el módulo para su proveedor de validación. Agregue la etiqueta replace-with en su archivo gwt modle que le indica a GWT que use el Validator que acaba de definir (consulte 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

Es complicado, pero para obtener la ruta 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 ().

Aunque no creo que sea posible hacer una validación externa; la validación se realiza en el editor en el momento en que se lee un valor del campo (consulte ValueBoxEditor - este editor usa getDelegate (). recordError para generar un error). Una opción que consideré fue usar el acceso AbstractEditorDelegate para llamar a flushErrors (Lista) y crear yo mismo la lista de EditorErrors. Para hacer eso necesitas conocer cada uno de tus caminos de campo; Codificarlos no es deseable, pero no veo una forma de buscar el Campo por la propiedad editada ni nada por el estilo.

Un enfoque alternativo que podría ser valioso es el envío de validación de ida y vuelta utilizando el factor de solicitud:

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

Answer 3

He hecho algo similar a esto al agregar una clase DriverWrapper adicional que toma el Controlador y el Validador existentes y agrega un método de descarga que primero delega el flujo del Controlador subyacente y luego llama al Validador. Cualquier error devuelto se agrega a los editores mediante 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));
}

Answer 4

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

Answer 5

Tengo exactamente el mismo problema.

La documentación no está clara al respecto.

Lo que estoy haciendo actualmente es recrear algunos widgets extendiéndolos 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 a suDelegate.recordError ().

Algo como esto: un pequeño cuadro de enteros que verifica que el valor no sea 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 una verificación personalizada a los widgets existentes y no anularlos, ¡pero no sé cómo hacerlo!