5:14 a.m.
Allow ordered validator's annotations
-------------------------------------
Key: HV-462
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-462
Project: Hibernate Validator
Issue Type: New Feature
Affects Versions: 4.1.0.Final
Reporter: Pavla Nováková
1) Consider domain object with simple constraints (just to demonstrate required feature,
my real example uses custom cost-expensive validation of pictures):
{code}
public class DomainObject {
@Size(max=50) // constraint 1a
@Pattern(regexp="[a-z]*") // constraint 1b
private String name;
@Size(max=20) // constraint 2a
@URL // constraint 2b
private String email;
@Size(max=100) // constraint 3a
@Pattern(regexp="[0-9]*") // constraint 3b
private String password;
{code}
2) Consider validation requirements:
* all properties should be validated together (like one virtual group)
* FOR EACH PROPERTY validation should occur in ordered steps given by order of annotations
for given property (if first validation step fails, SKIP following validation process on
given property and add validation message specific to failed / last validated constraint
for the property)
3) Why it is useful:
* simple cost-effective validation followed by cost-expensive validation (not executed if
simple constraint fails)
* we get just the "main and specific validation error" (otherwise we have to
iterate over all errors "to find the cause" or we display two or more errors for
one property which is not user-friendly according my opinion)
3) What is unusable:
* groups and group sequences (it is not possible to create proper combination of groups
and sequences for more than one property with two or more constraints)
* composed constraints (@ReportAsSingleViolation included)
** we cannot use @ReportAsSingleViolation since we want specific message for each failed
constraint
** and main problem is: if we use composed constraints all constraints are evaluated for
given property
4) Proposed solution:
* add optional order attribute to validator annotations and stop validation on first
failure if order is specified
* possibly this can be configured on global validator level with property
"skipOnFirstFailure" together with some given convention for annotation order
Please let me know if need better explanation or working examples.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
6:16 a.m.
New subject: [Hibernate-JIRA] Commented: (HV-462) Allow ordered validator's annotations
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-462?page=com...
]
Hardy Ferentschik commented on HV-462:
--------------------------------------
So, how is your solution different to this:
{code}
@GroupSequence({ Step1.class, Step2.class })
public class DomainObject {
@Size(max=50, groups = Step1.class)
@Pattern(regexp="[a-z]*", groups = Step2.class)
private String name;
@Size(max=20, groups = Step1.class)
@URL(groups = Step2.class)
private String email;
@Size(max=100, groups = Step1.class)
@Pattern(regexp="[0-9]*", groups = Step2.class)
private String password;
}
public interface Step1 {
}
public interface Step2 {
}
{code}
Allow ordered validator's annotations
-------------------------------------
Key: HV-462
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-462
Project: Hibernate Validator
Issue Type: New Feature
Affects Versions: 4.1.0.Final
Reporter: Pavla Nováková
1) Consider domain object with simple constraints (just to demonstrate required feature,
my real example uses custom cost-expensive validation of pictures):
{code}
public class DomainObject {
@Size(max=50) // constraint 1a
@Pattern(regexp="[a-z]*") // constraint 1b
private String name;
@Size(max=20) // constraint 2a
@URL // constraint 2b
private String email;
@Size(max=100) // constraint 3a
@Pattern(regexp="[0-9]*") // constraint 3b
private String password;
{code}
2) Consider validation requirements:
* all properties should be validated together (like one virtual group)
* FOR EACH PROPERTY validation should occur in ordered steps given by order of
annotations for given property (if first validation step fails, SKIP following validation
process on given property and add validation message specific to failed / last validated
constraint for the property)
3) Why it is useful:
* simple cost-effective validation followed by cost-expensive validation (not executed if
simple constraint fails)
* we get just the "main and specific validation error" (otherwise we have to
iterate over all errors "to find the cause" or we display two or more errors for
one property which is not user-friendly according my opinion)
3) What is unusable:
* groups and group sequences (it is not possible to create proper combination of groups
and sequences for more than one property with two or more constraints)
* composed constraints (@ReportAsSingleViolation included)
** we cannot use @ReportAsSingleViolation since we want specific message for each failed
constraint
** and main problem is: if we use composed constraints all constraints are evaluated for
given property
4) Proposed solution:
* add optional order attribute to validator annotations and stop validation on first
failure if order is specified
* possibly this can be configured on global validator level with property
"skipOnFirstFailure" together with some given convention for annotation order
Please let me know if need better explanation or working examples.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
3:45 p.m.
New subject: [Hibernate-JIRA] Commented: (HV-462) Allow ordered validator's annotations
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-462?page=com...
]
Pavla Nováková commented on HV-462:
-----------------------------------
Thank you Hardy for your comment, I'll try explain better the problem on solution you
suggest:
Let's start from the result we want after web form is submitted - consider user's
input and error messages that should display in form after validation:
* name=aron5 [Only letters a-z are valid for name field.] (Constraint 1a passes,
constraint 1b fails)
* email=MyTooLongEmailOverTwentyCharacters(a)somemail.com [Too long email address - maximum
is 20 characters.] (Constraint 2a fails, Constraint 2b should not be validated, since
previous step failed)
* password=SomePasswordWithLetters [Only numbers 0-9 are valid for password field.]
(Constraint 3a passes, constraint 3b fails)
Citation from Hibernate Validator manual:
"If at least one constraints fails in a sequenced group none of the constraints of
the following groups in the sequence get validated."
Using, what you suggested means, that Step1 group is validated first and it fails on email
property and so Step2 group validation is skipped. The result you get is:
* name=aron5 [MISSING ERROR MESSAGE]
* email=MyTooLongEmailOverTwentyCharacters(a)somemail.com [Too long email address - maximum
is 20 characters.] (correct)
* password=SomePasswordWithLetters [MISSING ERROR MESSAGE]
I hope I was clear enough and it does make sense.
Allow ordered validator's annotations
-------------------------------------
Key: HV-462
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-462
Project: Hibernate Validator
Issue Type: New Feature
Affects Versions: 4.1.0.Final
Reporter: Pavla Nováková
1) Consider domain object with simple constraints (just to demonstrate required feature,
my real example uses custom cost-expensive validation of pictures):
{code}
public class DomainObject {
@Size(max=50) // constraint 1a
@Pattern(regexp="[a-z]*") // constraint 1b
private String name;
@Size(max=20) // constraint 2a
@URL // constraint 2b
private String email;
@Size(max=100) // constraint 3a
@Pattern(regexp="[0-9]*") // constraint 3b
private String password;
{code}
2) Consider validation requirements:
* all properties should be validated together (like one virtual group)
* FOR EACH PROPERTY validation should occur in ordered steps given by order of
annotations for given property (if first validation step fails, SKIP following validation
process on given property and add validation message specific to failed / last validated
constraint for the property)
3) Why it is useful:
* simple cost-effective validation followed by cost-expensive validation (not executed if
simple constraint fails)
* we get just the "main and specific validation error" (otherwise we have to
iterate over all errors "to find the cause" or we display two or more errors for
one property which is not user-friendly according my opinion)
3) What is unusable:
* groups and group sequences (it is not possible to create proper combination of groups
and sequences for more than one property with two or more constraints)
* composed constraints (@ReportAsSingleViolation included)
** we cannot use @ReportAsSingleViolation since we want specific message for each failed
constraint
** and main problem is: if we use composed constraints all constraints are evaluated for
given property
4) Proposed solution:
* add optional order attribute to validator annotations and stop validation on first
failure if order is specified
* possibly this can be configured on global validator level with property
"skipOnFirstFailure" together with some given convention for annotation order
Please let me know if need better explanation or working examples.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
10:09 a.m.
New subject: [Hibernate-JIRA] Commented: (HV-462) Allow ordered validator's annotations
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-462?page=com...
]
Hardy Ferentschik commented on HV-462:
--------------------------------------
I see where you are coming from. I still it is possible with the current approach, but
cumbersome:
{code}
public class DomainObject {
@Size(max=50, groups = NameStep1.class)
@Pattern(regexp="[a-z]*", groups = NameStep2.class)
private String name;
@Size(max=20, groups = EmailStep1.class)
@URL(groups = EmailStep2.class)
private String email;
}
@GroupSequence({ NameStep1.class, NameStep2.class })
public interface NameSequence{
}
public interface NameStep1 {
}
public interface NameStep2 {
}
@GroupSequence({ EmailStep1.class, EmailStep2.class })
public interface EmailSequence{
}
public interface EmailStep1 {
}
public interface EmailStep2 {
}
{code}
At validation time you would then validate the groups _NameSequence_ and _EmailSequence_.
Obviously {quote}validation should occur in ordered steps given by order of annotations
for given property{quote} is not possible, because there is no way to introspect the order
of annotations for a given property. Leaves the _order_ which is really a change the Bean
Validation spec and should be discussed there. I wonder how such an attribute would then
tie in with the current group and group sequence mechanism?
Allow ordered validator's annotations
-------------------------------------
Key: HV-462
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-462
Project: Hibernate Validator
Issue Type: New Feature
Affects Versions: 4.1.0.Final
Reporter: Pavla Nováková
Fix For: 4.x
1) Consider domain object with simple constraints (just to demonstrate required feature,
my real example uses custom cost-expensive validation of pictures):
{code}
public class DomainObject {
@Size(max=50) // constraint 1a
@Pattern(regexp="[a-z]*") // constraint 1b
private String name;
@Size(max=20) // constraint 2a
@URL // constraint 2b
private String email;
@Size(max=100) // constraint 3a
@Pattern(regexp="[0-9]*") // constraint 3b
private String password;
{code}
2) Consider validation requirements:
* all properties should be validated together (like one virtual group)
* FOR EACH PROPERTY validation should occur in ordered steps given by order of
annotations for given property (if first validation step fails, SKIP following validation
process on given property and add validation message specific to failed / last validated
constraint for the property)
3) Why it is useful:
* simple cost-effective validation followed by cost-expensive validation (not executed if
simple constraint fails)
* we get just the "main and specific validation error" (otherwise we have to
iterate over all errors "to find the cause" or we display two or more errors for
one property which is not user-friendly according my opinion)
3) What is unusable:
* groups and group sequences (it is not possible to create proper combination of groups
and sequences for more than one property with two or more constraints)
* composed constraints (@ReportAsSingleViolation included)
** we cannot use @ReportAsSingleViolation since we want specific message for each failed
constraint
** and main problem is: if we use composed constraints all constraints are evaluated for
given property
4) Proposed solution:
* add optional order attribute to validator annotations and stop validation on first
failure if order is specified
* possibly this can be configured on global validator level with property
"skipOnFirstFailure" together with some given convention for annotation order
Please let me know if need better explanation or working examples.
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
10:09 a.m.
New subject: [Hibernate-JIRA] Updated: (HV-462) Allow ordered validator's annotations
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-462?page=com...
]
Hardy Ferentschik updated HV-462:
---------------------------------
Fix Version/s: 4.x
Allow ordered validator's annotations
-------------------------------------
Key: HV-462
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-462
Project: Hibernate Validator
Issue Type: New Feature
Affects Versions: 4.1.0.Final
Reporter: Pavla Nováková
Fix For: 4.x
1) Consider domain object with simple constraints (just to demonstrate required feature,
my real example uses custom cost-expensive validation of pictures):
{code}
public class DomainObject {
@Size(max=50) // constraint 1a
@Pattern(regexp="[a-z]*") // constraint 1b
private String name;
@Size(max=20) // constraint 2a
@URL // constraint 2b
private String email;
@Size(max=100) // constraint 3a
@Pattern(regexp="[0-9]*") // constraint 3b
private String password;
{code}
2) Consider validation requirements:
* all properties should be validated together (like one virtual group)
* FOR EACH PROPERTY validation should occur in ordered steps given by order of
annotations for given property (if first validation step fails, SKIP following validation
process on given property and add validation message specific to failed / last validated
constraint for the property)
3) Why it is useful:
* simple cost-effective validation followed by cost-expensive validation (not executed if
simple constraint fails)
* we get just the "main and specific validation error" (otherwise we have to
iterate over all errors "to find the cause" or we display two or more errors for
one property which is not user-friendly according my opinion)
3) What is unusable:
* groups and group sequences (it is not possible to create proper combination of groups
and sequences for more than one property with two or more constraints)
* composed constraints (@ReportAsSingleViolation included)
** we cannot use @ReportAsSingleViolation since we want specific message for each failed
constraint
** and main problem is: if we use composed constraints all constraints are evaluated for
given property
4) Proposed solution:
* add optional order attribute to validator annotations and stop validation on first
failure if order is specified
* possibly this can be configured on global validator level with property
"skipOnFirstFailure" together with some given convention for annotation order
Please let me know if need better explanation or working examples.
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
10:29 a.m.
New subject: [Hibernate-JIRA] Commented: (HV-462) Allow ordered validator's annotations
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-462?page=com...
]
Hardy Ferentschik commented on HV-462:
--------------------------------------
This can really only be addressed from the spec - BVAL-248
Allow ordered validator's annotations
-------------------------------------
Key: HV-462
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-462
Project: Hibernate Validator
Issue Type: New Feature
Affects Versions: 4.1.0.Final
Reporter: Pavla Nováková
Fix For: 4.x
1) Consider domain object with simple constraints (just to demonstrate required feature,
my real example uses custom cost-expensive validation of pictures):
{code}
public class DomainObject {
@Size(max=50) // constraint 1a
@Pattern(regexp="[a-z]*") // constraint 1b
private String name;
@Size(max=20) // constraint 2a
@URL // constraint 2b
private String email;
@Size(max=100) // constraint 3a
@Pattern(regexp="[0-9]*") // constraint 3b
private String password;
{code}
2) Consider validation requirements:
* all properties should be validated together (like one virtual group)
* FOR EACH PROPERTY validation should occur in ordered steps given by order of
annotations for given property (if first validation step fails, SKIP following validation
process on given property and add validation message specific to failed / last validated
constraint for the property)
3) Why it is useful:
* simple cost-effective validation followed by cost-expensive validation (not executed if
simple constraint fails)
* we get just the "main and specific validation error" (otherwise we have to
iterate over all errors "to find the cause" or we display two or more errors for
one property which is not user-friendly according my opinion)
3) What is unusable:
* groups and group sequences (it is not possible to create proper combination of groups
and sequences for more than one property with two or more constraints)
* composed constraints (@ReportAsSingleViolation included)
** we cannot use @ReportAsSingleViolation since we want specific message for each failed
constraint
** and main problem is: if we use composed constraints all constraints are evaluated for
given property
4) Proposed solution:
* add optional order attribute to validator annotations and stop validation on first
failure if order is specified
* possibly this can be configured on global validator level with property
"skipOnFirstFailure" together with some given convention for annotation order
Please let me know if need better explanation or working examples.
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
3:18 a.m.
New subject: [Hibernate-JIRA] Updated: (HV-462) Allow ordered validator's annotations
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-462?page=com...
]
Hardy Ferentschik updated HV-462:
---------------------------------
Component/s: validators
engine
Allow ordered validator's annotations
-------------------------------------
Key: HV-462
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-462
Project: Hibernate Validator
Issue Type: New Feature
Components: engine, validators
Affects Versions: 4.1.0.Final
Reporter: Pavla Nováková
Fix For: 4.x
1) Consider domain object with simple constraints (just to demonstrate required feature,
my real example uses custom cost-expensive validation of pictures):
{code}
public class DomainObject {
@Size(max=50) // constraint 1a
@Pattern(regexp="[a-z]*") // constraint 1b
private String name;
@Size(max=20) // constraint 2a
@URL // constraint 2b
private String email;
@Size(max=100) // constraint 3a
@Pattern(regexp="[0-9]*") // constraint 3b
private String password;
{code}
2) Consider validation requirements:
* all properties should be validated together (like one virtual group)
* FOR EACH PROPERTY validation should occur in ordered steps given by order of
annotations for given property (if first validation step fails, SKIP following validation
process on given property and add validation message specific to failed / last validated
constraint for the property)
3) Why it is useful:
* simple cost-effective validation followed by cost-expensive validation (not executed if
simple constraint fails)
* we get just the "main and specific validation error" (otherwise we have to
iterate over all errors "to find the cause" or we display two or more errors for
one property which is not user-friendly according my opinion)
3) What is unusable:
* groups and group sequences (it is not possible to create proper combination of groups
and sequences for more than one property with two or more constraints)
* composed constraints (@ReportAsSingleViolation included)
** we cannot use @ReportAsSingleViolation since we want specific message for each failed
constraint
** and main problem is: if we use composed constraints all constraints are evaluated for
given property
4) Proposed solution:
* add optional order attribute to validator annotations and stop validation on first
failure if order is specified
* possibly this can be configured on global validator level with property
"skipOnFirstFailure" together with some given convention for annotation order
Please let me know if need better explanation or working examples.
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
11:22 a.m.
New subject: [Hibernate-JIRA] Updated: (HV-462) Allow ordered validator's annotations
[
https://hibernate.onjira.com/browse/HV-462?page=com.atlassian.jira.plugin...
]
Hardy Ferentschik updated HV-462:
---------------------------------
Fix Version/s: (was: 4.3.0.Final)
5.x
Allow ordered validator's annotations
-------------------------------------
Key: HV-462
URL: https://hibernate.onjira.com/browse/HV-462
Project: Hibernate Validator
Issue Type: New Feature
Components: engine, validators
Affects Versions: 4.1.0.Final
Reporter: Pavla Nováková
Fix For: 5.x
1) Consider domain object with simple constraints (just to demonstrate required feature,
my real example uses custom cost-expensive validation of pictures):
{code}
public class DomainObject {
@Size(max=50) // constraint 1a
@Pattern(regexp="[a-z]*") // constraint 1b
private String name;
@Size(max=20) // constraint 2a
@URL // constraint 2b
private String email;
@Size(max=100) // constraint 3a
@Pattern(regexp="[0-9]*") // constraint 3b
private String password;
{code}
2) Consider validation requirements:
* all properties should be validated together (like one virtual group)
* FOR EACH PROPERTY validation should occur in ordered steps given by order of
annotations for given property (if first validation step fails, SKIP following validation
process on given property and add validation message specific to failed / last validated
constraint for the property)
3) Why it is useful:
* simple cost-effective validation followed by cost-expensive validation (not executed if
simple constraint fails)
* we get just the "main and specific validation error" (otherwise we have to
iterate over all errors "to find the cause" or we display two or more errors for
one property which is not user-friendly according my opinion)
3) What is unusable:
* groups and group sequences (it is not possible to create proper combination of groups
and sequences for more than one property with two or more constraints)
* composed constraints (@ReportAsSingleViolation included)
** we cannot use @ReportAsSingleViolation since we want specific message for each failed
constraint
** and main problem is: if we use composed constraints all constraints are evaluated for
given property
4) Proposed solution:
* add optional order attribute to validator annotations and stop validation on first
failure if order is specified
* possibly this can be configured on global validator level with property
"skipOnFirstFailure" together with some given convention for annotation order
Please let me know if need better explanation or working examples.
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
4083
days inactive
4754
days old
hibernate-issues@lists.jboss.org
8 comments
3 participants
participants (3)
-
Emmanuel Bernard (JIRA) -
Hardy Ferentschik (JIRA)
-
Pavla Nováková (JIRA)