Come utilizzare il framework dell'editor GWT per la convalida?

Question

Sto cercando di integrarmi con il nuovo framework GWT Editor di GWT 2.1.0. Voglio anche aggiungere i miei controlli di convalida nel framework. Tuttavia, sto lottando per trovare un esempio decente su come farlo.

Per il momento ho il seguente codice:

<!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> 

E per il mio editore:

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)); 
    } 

} 

Su quale punto devo chiamare il mio validatore e come posso integrare con esso?

Aggiornamento:

Sono in realtà alla ricerca di un modo per recuperare una mappa con il percorso come la chiave di proprietà, e come valore di l'editor. C'è un campo percorso su un delegato, ma questo non è il percorso all'interno dell'oggetto modificato, ma il percorso nella classe dell'editor.

Qualcuno sa se è possibile fare qualcosa di simile?

Answer 1

Annotazione vi fagioli con contstrants (vedi Person.java)

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

Utilizzare il bootstrap di convalida standard per ottenere un validatore sul client e convalidare l'oggetto (vedere ValidationView.java)

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

Seguire questo modello per creare un Validatore per gli oggetti che si desidera convalidare sul client. (Vedi 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); 
    } 
} 

includere il modulo per il provider di convalida. Aggiungere replace-con il tag nel file di modello GWT dicendo GWT di utilizzare il Validator appena definito (vedi 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 convalida non esiste ancora in GWT, è in arrivo nella prossima versione AFAIK. L'attuale supporto per la convalida in GWT è lato server JSR-303 e il supporto JSR-303 lato client è in arrivo. Pertanto, dovrai eseguire la convalida manualmente. Se segui il modello MVP, penso che questa logica di convalida possa vivere nel tuo Presenter.

Answer 3

Ho esattamente lo stesso problema.

La documentazione non è chiara a riguardo.

Quello che sto facendo è ricreare alcuni widget estendendoli con il widget che voglio copiare. Dopo di esso implemento LeafValueEditor e HasEditorDelegate per sovrascrivere getValue().

In getValue(), utilizzare il validatore e chiamare se necessario yourDelegate.recordError().

Qualcosa di simile a questo: una piccola scatola intero che verificare che il valore non sia superiore a 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; 
} 
} 

L'approccio migliore è quello di aggiungere semplicemente la verifica personalizzata per i widget esistenti e non li sostituire, ma io no sai come farlo!

Answer 4

È complicato ma per ottenere il percorso di un editor è possibile implementare HasEditorDelegate (che consente di accedere al delegato) e quindi eseguire il cast del delegato in AbstractEditorDelegate, che dispone di un metodo pubblico String getPath().

Non penso che sia possibile eseguire la convalida esterna; la convalida avviene nell'editor nel punto in cui un valore viene letto dal campo (vedi ValueBoxEditor - questo editor usa getDelegate(). recordError per generare un errore). Un'opzione che ho considerato era quella di utilizzare l'accesso AbstractEditorDelegate per chiamare flushErrors (List) e creare personalmente l'elenco di EditorErrors. Per farlo devi conoscere ognuno dei tuoi percorsi di campagna; il loro hardcoding è appena desiderabile, ma non vedo un modo di guardare il campo dalla proprietà modificata o qualcosa del genere.

Un approccio alternativo che potrebbe orso esaminando è questa sottomissione per la convalida di andata e ritorno con il requestfactory:

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

Answer 5

ho fatto qualcosa di simile a questo con l'aggiunta di una classe DriverWrapper aggiuntivo che prende il driver e il validatore esistenti e aggiunge un metodo flush che prima delega al driver Driver sottostante e quindi chiama il Validator. Eventuali errori restituiti vengono quindi aggiunti agli Editor utilizzando un nuovo visitatore, in modo simile al funzionamento del Flusher esistente. Ciò significa che i decoratori esistenti che visualizzano gli errori accanto ai campi continuano a funzionare.

/** 
* 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)); 
}