Cómo utilizar el marco editor de GWT para la validación?
https://stackoverflow.com/questions/4098579
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
Estoy tratando de integrarse con el nuevo marco GWT Editor de GWT 2.1.0. También quiero añadir mis comprobaciones de validación en el marco. Sin embargo, estoy luchando para encontrar un ejemplo digno 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é momento tengo que llamar a mi validador y cómo se integran con él?
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 de un delegado, pero este no es el camino dentro del objeto editado, pero el camino de la clase editor.
¿Alguien sabe si es posible hacer algo como esto?
Solución
Anotar que los frijoles con contstrants (ver Person.java )
public class Person {
@Size(min = 4)
private String name;
}
Usar el sistema de arranque de validación estándar para obtener un validador en el cliente y validar su objeto (ver 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);
}
}
Incluir el módulo de su proveedor de validación. Agregar replace-con la etiqueta en su archivo de GWT GWT modle diciendo a 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>
Otros consejos
he hecho algo similar a esto añadiendo una clase DriverWrapper adicional que lleva el controlador existente y Validador y añade un método flush que los primeros delegados al ras del conductor subyacente y luego llama al validador. Cualquier error devueltos se añaden a los editores que utilizan un nuevo visitante, similar a la forma en que funciona la máquina de enjuague existente. Esto significa que los decoradores existentes que muestran los errores junto a los campos continúan trabajando.
/**
* 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));
}
Tengo exaclty el mismo problema.
La documentación no es clara al respecto.
Lo que estoy haciendo actualmente es recrear algunos widgets extendiéndolas con Reproductor quiero copiar. Después de que se implemento LeafValueEditor y HasEditorDelegate para anular getValue ().
En getValue (), utilice el validador y la llamada si es necesario yourDelegate.recordError ().
Algo como esto:. Una pequeña caja número 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 no sé cómo hacerlo!
La validación no existe en GWT, sin embargo, que viene en la próxima versión que yo sepa. El apoyo actual para la validación de GWT es del lado del servidor JSR-303 y el lado del cliente JSR-303 de apoyo estará disponible en breve. Por lo tanto, usted tiene que hacer la validación manual. Si sigue el modelo de MVP, creo que esta lógica de validación sería vivir en su presentador.
desordenado Es pero para obtener el camino de un editor podría implementar HasEditorDelegate (que le dará acceso al delegado) y luego emitir el Delegado de AbstractEditorDelegate, que cuenta con un método public String getPath ().
No creo que es posible hacer una validación externa sin embargo; validación sucede en el editor en el punto de que un valor se lee desde el campo (ver ValueBoxEditor - este editor usa getDelegate () recordError para elevar un error.). Una opción que consideré era utilizar el acceso AbstractEditorDelegate llamar flushErrors (Lista) y para crear esa lista de EditorErrors mí mismo. Para ello es necesario conocer cada uno de sus caminos de tierra; hardcoding ellos no es deseable, pero no veo una manera de ver el campo de la propiedad editada ni nada de eso.
Un enfoque alternativo que podría llevar mirando en esta presentación es para la validación de ida y vuelta con el RequestFactory:
