Validation de formulaire avec le classeur

Question

Comment terminer la validation avec l'envoi de toutes les données de formulaire dans Vaadin 8? Malheureusement, je ne comprends pas le concept de liant :(J'ai écrit une validation sur le terrain, mais qu'est-ce que ça fait? Mon utilisateur voit quand je lui demande de remplir un champ mais y a-t-il un moyen facile de valider mon formulaire? à mon bouton de sauvegarde que ma forme est valide

Dans mon éditeur Im définissant un validateur

@SpringComponent 
@PrototypeScope 
public class VaadinStringEditor extends TextField implements HasValueComponent<String> { 

    private Binder<String> binder; 
    BinderValidationStatus<String> status; 
    @PostConstruct 
    public void init() { 
     setWidth("100%"); 
     binder = new Binder<>(); 
    } 

    @Override 
    public void initDefaults() { 
     setValue(""); 
     status = binder.validate(); 

    } 

    @Override 
    public void setConfiguration(EditorConfiguration editorConfiguration) { 
     Validator<String> validator = ((TextFieldConfiguration) editorConfiguration).getValidator(); 
     if (validator != null) { 
      binder.forField(this).withValidator(validator).asRequired("Mandatory").bind(s -> getValue(), 
        (b, v) -> setValue(v)); 

     } 

    public BinderValidationStatus<String> getStatus() { 
    return status; 
    } 

    public void setStatus(BinderValidationStatus<String> status) { 
    this.status = status; 
    } 

    public boolean validate() { 
    BinderValidationStatus<String> status = binder.validate(); 
    return status.isOk(); 
    } 

    } 

} 

J'ai aussi un TextEditorConfiguration ajouté:

public class TextFieldConfiguration implements EditorConfiguration { 

    private Validator<String> validator; 
    private int validated; 

    public TextFieldConfiguration(Validator<String> validator) { 
     this.validator = validator; 

    } 
    public TextFieldConfiguration() { 
     this.validator = null; 
    } 
    public Validator<String> getValidator() { 
     return validator; 

    } 
    public int getValidated() { 
     return validated; 
    } 
    public void setValidated(int validated) { 
     this.validated = validated; 
    } 
} 

Dans mon cas, il y a beaucoup d'éditeurs comme DateEditor et ainsi de suite. Validation de l'interface utilisateur fonctionne bien. Depuis un mois, je ne peux pas trouver un moyen de le connecter à soumettre le bouton pour éviter d'envoyer un formulaire.

Dans la classe de formulaire I ont défini toutes les questions par exemple:

question = new AseQuestion(AseQuestionId.DATE_OF_NOTIFICATION, EditorType.DATE_EDITOR); 
question.setDescription(
     "When it happend?"); 
question.setEditorConfiguration(new DateFieldConfiguration(dateRequiredValidator(), dateNotAllowedValidator())); 
return question; 
question = new AseQuestion(AseQuestionId.QUESTION2, EditorType.STRING_EDITOR); 
question.setDescription(" 
      "Write something"); 
private Validator<String> textRequiredValidator() { 
    return Validator.from(v -> v != null && StringUtils.trimAllWhitespace((String) v).length() != 0, 
      "It cannot be empty!!!"); 

Et la classe où j'ai un bouton soumettre

public class QuestionWindow extends Window { 
    @Autowired 
    private transient VaadinStringEditor editor; 

    private Button createSaveButton() { 
     Button saveButton = new Button(i18n.getWithDefault("newAseQuestions.save", "Übernehmen")); 

     saveButton.addClickListener(e -> { 
      if (editor.getBinder.validate()) { 
       Notification.show("This is the caption OK", "This is the description", 
         Notification.Type.HUMANIZED_MESSAGE); 
      } else { 
       Notification.show("This is the caption", "This is the description", 
         Notification.Type.HUMANIZED_MESSAGE); 
       System.out.println("kurwa"); 
      } 

      saveAse(); 
     }); 
     return saveButton; 
    } 

Answer 1

OK permet de supposer que nous havre de paix cette POJO:

public class Person { 
    private String firstname; 
    private String lastname; 

    public String getFirstname() { 
     return firstname; 
    } 

    public void setFirstname(String firstname) { 
     this.firstname = firstname; 
    } 

    public String getLastname() { 
     return lastname; 
    } 

    public void setLastname(String lastname) { 
     this.lastname = lastname; 
    } 

} 

Et nous voulons l'éditer. Nous construisons la forme suivante:

public class Form { 
    private TextField firstname; 
    private TextField lastname; 

    private Binder<Person> binder = new Binder<>(); 

    void bindFields() { 
     binder.forField(firstname).withValidator(textRequiredValidator()) 
      .asRequired("Mandatory").bind(Person::getFirstname, Person::setFirstname); 
     binder.forField(lastname).withValidator(textRequiredValidator()) 
      .asRequired("Mandatory").bind(Person::getLastname, Person::setLastname); 
    } 

    public void setDatasource(Person person) { 
     binder.setBean(person); 
    } 

    private Validator<String> textRequiredValidator() { 
     return Validator.from(v -> v != null && StringUtils.trimAllWhitespace((String) v).length() != 0, 
      "It cannot be empty!!!"); 
    } 

    public boolean validate() { 
     BinderValidationStatus<Person> status = binder.validate(); 
     return status.isOk(); 
    } 
} 

Pour utiliser ce formulaire, nous devons appeler bindFields premier (par exemple constructeur, init). Ou alors, appelez un contrôleur setDatasource avec la personne que nous voulons modifier. Après cela, l'utilisateur peut remplir ou modifier le formulaire et lorsque l'utilisateur termine l'état du formulaire peut être récupéré via valider.

Si vous avez besoin des erreurs des champs, vous les obtenez à partir du BinderValidationStatus.

Pour plus d'information au regard https://vaadin.com/docs/v8/framework/datamodel/datamodel-forms.html