Package org.vaadin.firitin.form

Class FormBinder<T>

java.lang.Object
org.vaadin.firitin.form.FormBinder<T>
Type Parameters:
T - The class/record type bound by this binder.
All Implemented Interfaces:
com.vaadin.flow.component.HasValue<FormBinderValueChangeEvent<T>,T>, Serializable
public class FormBinder<T> extends Object implements com.vaadin.flow.component.HasValue<FormBinderValueChangeEvent<T>,T>
A new start for the Binder. Note, that this is still a fairly new class, so there might be API changes to it.

Design principles:

  • Only support "non-buffered mode" so that validation logic can use the bean/record + simplicity of the implementation
  • Validation is "just validation", and not concern of this class. BUT, API must support binding external validation logic, like Bean Validation API
  • Must support Records and immutable objects as well
  • No requirements for BeanValidation or Spring DataBinding stuff, but optional support (or extensible for those)
Non-goals:
  • Aiming for binding anything without property names (for good solution this needs to be resolved at language level and supported with thing like Bean Validation first)
See Also:

  • Constructor Details

    • FormBinder

      public FormBinder(Class<T> tClass, com.vaadin.flow.component.Component... containerComponents)
      Constructs a new binder.
      Parameters:
      tClass - the class of the bound entity/bean, set later with setValue(Object)
      containerComponents - the components whose class contains the fields to bound

    • FormBinder

      @Deprecated public FormBinder(Class<T> tClass, Object editorObject)
      Deprecated.
      not sure yet if this is a good idea, added for backwards compatibility
      Constructs a new binder.
      Parameters:
      tClass - the class of the bound entity/bean, set later with setValue(Object)
      editorObject - the editor object that contains the fields to bound, does not need to be a component

    • FormBinder

      public FormBinder(Class<T> tClass, Map<String,com.vaadin.flow.component.HasValue> propertyNameToEditor)
      Binds type to given property editors
      Parameters:
      tClass - the type to bind
      propertyNameToEditor - pre-instantiated editors to bind

    • FormBinder

      public FormBinder(T dto, com.vaadin.flow.component.Component... containerComponents)
      Binds given dto to the UI fields found from given component(s).
      Parameters:
      dto - the object to bind. The type of the FormBinder will be taken from this object.
      containerComponents - the components whose class contains the fields to bound

  • Method Details

    • isRequired

      protected static boolean isRequired(com.fasterxml.jackson.databind.introspect.BeanPropertyDefinition property)

    • configureEditor

      protected void configureEditor(com.fasterxml.jackson.databind.introspect.BeanPropertyDefinition property, com.vaadin.flow.component.HasValue hasValue)

    • handleInputConversionError

      protected Object handleInputConversionError(com.fasterxml.jackson.databind.introspect.BeanPropertyDefinition property, com.vaadin.flow.data.binder.ValueContext ctx, String conversionErrorMsg)
      Handles input conversion error. By default, the error message saved and set to the field.
      Parameters:
      property -
      ctx -
      conversionErrorMsg -
      Returns:
      the value to be set to the edited object, null by default

    • getValue

      public T getValue()
      Specified by:
      getValue in interface com.vaadin.flow.component.HasValue<FormBinderValueChangeEvent<T>,T>

    • setValue

      public void setValue(T valueObject)
      Sets the value object bound to this form
      Specified by:
      setValue in interface com.vaadin.flow.component.HasValue<FormBinderValueChangeEvent<T>,T>
      Parameters:
      valueObject - the new value

    • withValue

      public FormBinder<T> withValue(T value)

    • addValueChangeListener

      public com.vaadin.flow.shared.Registration addValueChangeListener(com.vaadin.flow.component.HasValue.ValueChangeListener<? super FormBinderValueChangeEvent<T>> listener)
      Specified by:
      addValueChangeListener in interface com.vaadin.flow.component.HasValue<FormBinderValueChangeEvent<T>,T>

    • isReadOnly

      public boolean isReadOnly()
      Specified by:
      isReadOnly in interface com.vaadin.flow.component.HasValue<FormBinderValueChangeEvent<T>,T>

    • setReadOnly

      public void setReadOnly(boolean readOnly)
      Specified by:
      setReadOnly in interface com.vaadin.flow.component.HasValue<FormBinderValueChangeEvent<T>,T>

    • isRequiredIndicatorVisible

      public boolean isRequiredIndicatorVisible()
      Specified by:
      isRequiredIndicatorVisible in interface com.vaadin.flow.component.HasValue<FormBinderValueChangeEvent<T>,T>

    • setRequiredIndicatorVisible

      public void setRequiredIndicatorVisible(boolean requiredIndicatorVisible)
      Specified by:
      setRequiredIndicatorVisible in interface com.vaadin.flow.component.HasValue<FormBinderValueChangeEvent<T>,T>

    • isImmutable

      protected boolean isImmutable()

    • constructRecord

      protected T constructRecord()

    • constructPojo

      protected T constructPojo()

    • setConstraintViolations

      public void setConstraintViolations(Set<jakarta.validation.ConstraintViolation<T>> violations)
      Set the constraint violations found during validation. If violation is bound to a bound property, it is shown next to the field, otherwise shown at "form level", see setClassLevelViolationDisplay(HasComponents).
      Parameters:
      violations - the constraint violations that should be shown in the UI

    • getClassLevelViolationDisplay

      public com.vaadin.flow.component.HasComponents getClassLevelViolationDisplay()
      Gets the class level violation display. If not set, the first container component is used if of appropriate type.
      Returns:
      the component where constraint violations will be displayed

    • setClassLevelViolationDisplay

      public void setClassLevelViolationDisplay(com.vaadin.flow.component.HasComponents display)
      Sets the container component where "class level" constraint violations are displayed.
      Parameters:
      display - the component where the "class level" constraint violations will be displayed.

    • handleClassLevelValidations

      protected void handleClassLevelValidations(Set<jakarta.validation.ConstraintViolation<T>> violations)

    • setRawConstraintViolations

      @Deprecated public void setRawConstraintViolations(Map<String,String> propertyToViolation)
      Deprecated.
      try to use the standard Java Bean Validation API based method instead
      An alternative API to report constraint violations without BeanValidation on the classpath.
      Parameters:
      propertyToViolation -

    • clearValidationErrors

      public void clearValidationErrors()
      Removes all validation errors from bound fields and getClassLevelViolationDisplay().

    • setConverter

      public void setConverter(String property, com.vaadin.flow.data.converter.Converter<?,?> strToDt)
      Sets a converter to use between the domain model property and the corresponding UI component editing it.
      Parameters:
      property - the property
      strToDt - the converter

    • hasInputConversionErrors

      public boolean hasInputConversionErrors()
      Checks if there have recently been errors to convert value from the UI to the domain object.
      Returns:
      true if there are active conversion errors

    • getInputConversionErrors

      public Map<String,String> getInputConversionErrors()
      Returns a map containing input conversion errors (propertyname-error).
      Returns:
      input conversion errors

    • isValid

      public boolean isValid()
      Returns:
      true if the binging looks valid for the user: no displayed constraint violations nor input conversion errors.

    • setIgnoreServerOriginatedChanges

      public void setIgnoreServerOriginatedChanges(boolean ignore)
      A flag to control whether server originated value change events should be ignored. Currently only known to be needed for testing, might be removed in the future.
      Parameters:
      ignore - true if non-client originated events should be ignored

    • unBind

      public void unBind()
      Clears bindings, might be needed to clean up references if e.g. re-using fields

    • getBoundProperties

      public List<String> getBoundProperties()

    • getEditor

      public com.vaadin.flow.component.HasValue getEditor(String property)