import java.io.Serializable;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
-import java.util.Arrays;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
}
}
- private static class NestedBeanPropertyDefinition<T, V>
+ /**
+ * Contains properties for a bean type which is nested in another
+ * definition.
+ *
+ * @since
+ * @param <T>
+ * the bean type
+ * @param <V>
+ * the value type returned by the getter and set by the setter
+ */
+ public static class NestedBeanPropertyDefinition<T, V>
extends AbstractBeanPropertyDefinition<T, V> {
private final PropertyDefinition<T, ?> parent;
return new SerializedPropertyDefinition(getPropertySet().beanType,
parent.getName() + "." + getName());
}
+
+ /**
+ * Gets the parent property definition.
+ *
+ * @return the property definition for the parent
+ */
+ public PropertyDefinition<T, ?> getParent() {
+ return parent;
+ }
}
private static final ConcurrentMap<Class<?>, BeanPropertySet<?>> instances = new ConcurrentHashMap<>();
import javax.validation.metadata.ConstraintDescriptor;
import javax.validation.metadata.PropertyDescriptor;
+import com.vaadin.data.BeanPropertySet.NestedBeanPropertyDefinition;
import com.vaadin.data.util.BeanUtil;
import com.vaadin.data.validator.BeanValidator;
* <p>
* By default the {@link RequiredFieldConfigurator#DEFAULT} configurator is
* used.
- *
+ *
* @param configurator
* required indicator configurator, may be {@code null}
*/
/**
* Gets field required indicator configuration logic.
- *
+ *
* @see #setRequiredConfigurator(RequiredFieldConfigurator)
- *
+ *
* @return required indicator configurator, may be {@code null}
*/
public RequiredFieldConfigurator getRequiredConfigurator() {
protected BindingBuilder<BEAN, ?> configureBinding(
BindingBuilder<BEAN, ?> binding,
PropertyDefinition<BEAN, ?> definition) {
- BeanValidator validator = new BeanValidator(beanType,
+ Class<?> actualBeanType = findBeanType(beanType, definition);
+ BeanValidator validator = new BeanValidator(actualBeanType,
definition.getName());
if (requiredConfigurator != null) {
configureRequired(binding, definition, validator);
return binding.withValidator(validator);
}
+ /**
+ * Finds the bean type containing the property the given definition refers
+ * to.
+ *
+ * @param beanType
+ * the root beanType
+ * @param definition
+ * the definition for the property
+ * @return the bean type containing the given property
+ */
+ @SuppressWarnings({ "rawtypes" })
+ private Class<?> findBeanType(Class<BEAN> beanType,
+ PropertyDefinition<BEAN, ?> definition) {
+ if (definition instanceof NestedBeanPropertyDefinition) {
+ return ((NestedBeanPropertyDefinition) definition).getParent()
+ .getType();
+ } else {
+ // Non nested properties must be defined in the main type
+ return beanType;
+ }
+ }
+
private void configureRequired(BindingBuilder<BEAN, ?> binding,
PropertyDefinition<BEAN, ?> definition, BeanValidator validator) {
assert requiredConfigurator != null;
import org.junit.Before;
import org.junit.Test;
+import com.vaadin.data.BeanBinderTest.RequiredConstraints.SubConstraint;
+import com.vaadin.data.BeanBinderTest.RequiredConstraints.SubSubConstraint;
import com.vaadin.data.converter.StringToIntegerConverter;
import com.vaadin.tests.data.bean.BeanToValidate;
import com.vaadin.ui.CheckBoxGroup;
private TextField number = new TextField();
}
- private static class TestBean implements Serializable{
+ private static class TestBean implements Serializable {
private Set<TestEnum> enums;
private int number;
}
}
- public static class RequiredConstraints implements Serializable{
+ public static class RequiredConstraints implements Serializable {
@NotNull
@Max(10)
private String firstname;
private String lastname;
private SubConstraint subfield;
-
+
public String getFirstname() {
return firstname;
}
public void setLastname(String lastname) {
this.lastname = lastname;
}
-
-
+
public SubConstraint getSubfield() {
return subfield;
}
this.subfield = subfield;
}
+ public static class SubConstraint implements Serializable {
- public static class SubConstraint implements Serializable{
-
@NotNull
+ @NotEmpty
+ @Size(min = 5)
private String name;
+ private SubSubConstraint subsub;
+
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
+
+ public SubSubConstraint getSubsub() {
+ return subsub;
+ }
+
+ public void setSubsub(SubSubConstraint subsub) {
+ this.subsub = subsub;
+ }
+
+ }
+
+ public static class SubSubConstraint implements Serializable {
+
+ @Size(min = 10)
+ private String value;
+
+ public String getValue() {
+ return value;
+ }
+
+ public void setValue(String value) {
+ this.value = value;
+ }
+
}
}
Assert.assertTrue(field.isRequiredIndicatorVisible());
testSerialization(binder);
}
-
+
@Test
public void subfield_name_fieldIsRequired() {
BeanValidationBinder<RequiredConstraints> binder = new BeanValidationBinder<>(
RequiredConstraints.class);
RequiredConstraints bean = new RequiredConstraints();
bean.setSubfield(new RequiredConstraints.SubConstraint());
-
+
TextField field = new TextField();
binder.bind(field, "subfield.name");
binder.setBean(bean);
testSerialization(binder);
}
+ @Test
+ public void subsubfield_name_fieldIsRequired() {
+ BeanValidationBinder<RequiredConstraints> binder = new BeanValidationBinder<>(
+ RequiredConstraints.class);
+ RequiredConstraints bean = new RequiredConstraints();
+ RequiredConstraints.SubConstraint subfield = new RequiredConstraints.SubConstraint();
+ subfield.setSubsub(new SubSubConstraint());
+ bean.setSubfield(subfield);
+
+ TextField field = new TextField();
+ binder.bind(field, "subfield.subsub.value");
+ binder.setBean(bean);
+
+ Assert.assertTrue(field.isRequiredIndicatorVisible());
+ testSerialization(binder);
+ }
+
+ @Test
+ public void subfield_name_valueCanBeValidated() {
+ BeanValidationBinder<RequiredConstraints> binder = new BeanValidationBinder<>(
+ RequiredConstraints.class);
+ TextField field = new TextField();
+
+ binder.bind(field, "subfield.name");
+ RequiredConstraints bean = new RequiredConstraints();
+ bean.setSubfield(new SubConstraint());
+ binder.setBean(bean);
+ Assert.assertFalse(binder.validate().isOk());
+ field.setValue("overfive");
+ Assert.assertTrue(binder.validate().isOk());
+ }
+
+ @Test
+ public void subSubfield_name_valueCanBeValidated() {
+ BeanValidationBinder<RequiredConstraints> binder = new BeanValidationBinder<>(
+ RequiredConstraints.class);
+ TextField field = new TextField();
+
+ binder.bind(field, "subfield.subsub.value");
+ RequiredConstraints bean = new RequiredConstraints();
+ SubConstraint subfield = new SubConstraint();
+ bean.setSubfield(subfield);
+ subfield.setSubsub(new SubSubConstraint());
+ binder.setBean(bean);
+
+ Assert.assertFalse(binder.validate().isOk());
+ field.setValue("overtencharacters");
+ Assert.assertTrue(binder.validate().isOk());
+ }
+
private void assertInvalid(HasValue<?> field, String message) {
BinderValidationStatus<?> status = binder.validate();
List<BindingValidationStatus<?>> errors = status
projects / vaadin-framework.git / commitdiff