Come utilizzare il framework per editor di GWT per la convalida?

Question

Sto cercando di integrarsi con il nuovo quadro GWT Editore di GWT 2.1.0. Voglio anche aggiungere i miei controlli di convalida nel quadro. Tuttavia, sto lottando per trovare un esempio decente come fare questo.

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

}

In che punto devo chiamare il mio validatore e come faccio a 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

Annota si fagioli con contstrants (vedi Person.java )

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

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

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

Seguire questo schema 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 la convalida Provider. Aggiungere replace-con il tag nel file di modello GWT dicendo GWT di utilizzare il Validator appena definito (si veda 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>

Fonte

Answer 2

Ho fatto qualcosa di simile a questo con l'aggiunta di una classe DriverWrapper aggiuntivo che prende il driver esistente e Validator e aggiunge un metodo flush che i primi delegati al sottostante filo driver e quindi chiama il Validator. Eventuali errori restituiti sono poi aggiunti agli editori che utilizzano un nuovo visitatore, simile al modo in cui funziona il Flusher esistente. Questo significa che i decoratori esistenti che visualizzano gli errori accanto ai campi continuare a lavorare.

/**
 * 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 3

devo farmi ridare lo stesso problema.

La documentazione non è chiaro a questo proposito.

Quello che sto facendo attualmente è quello di ricreare alcuni widget estendendole con widget di voglio copiare. Dopo che a implementare LeafValueEditor e HasEditorDelegate ignorare getValue ().

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

Qualcosa di simile a questo:. Una piccola scatola intero che verificare che il valore non è maggiore di 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 ignorare, ma non so come fare!

Answer 4

La convalida non esiste in GWT ancora, sta arrivando nella prossima release per quanto ne so. Il supporto corrente per la convalida in GWT è lato server JSR-303 e lato client il supporto JSR-303 sarà presto disponibile. Pertanto, si dovrà fare la convalida manualmente. Se si segue il modello MVP, penso che questa logica di convalida sarebbe vivere nella vostra Presenter.

Answer 5

E 'disordinato, ma per ottenere il percorso di un Editor è possibile implementare HasEditorDelegate (che vi darà accesso al delegato) e poi lanciare il Delegato per AbstractEditorDelegate, che ha un metodo pubblico String getPath ().

Non credo sia possibile fare validazione esterna però; validazione avviene nell'editor nel punto che un valore viene letto dal campo (vedi ValueBoxEditor - questo editor utilizza getDelegate () recordError per sollevare un errore.). Una possibilità ho considerato è stato quello di utilizzare l'accesso AbstractEditorDelegate di chiamare flushErrors (List) e per creare quella lista di EditorErrors me stesso. Per fare questo è necessario conoscere ognuno dei tuoi sentieri di campo; li hardcoding è certo auspicabile, ma non vedo un modo di guardare il campo dalla proprietà modificato o qualcosa di simile.

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

http://groups.google.com/ gruppo / google-web-toolkit-collaboratori / browse_thread / thread / 5be0bda80547ca5a