[JBoss JIRA] (FORGE-1667) Improve the constraint-new-annotation command
by Antonio Goncalves (JIRA)
Antonio Goncalves created FORGE-1667:
----------------------------------------
Summary: Improve the constraint-new-annotation command
Key: FORGE-1667
URL: https://issues.jboss.org/browse/FORGE-1667
Project: Forge
Issue Type: Sub-task
Components: Java EE
Affects Versions: 2.1.1.Final
Reporter: Antonio Goncalves
Fix For: 2.x Future
This allows the developer to create a constraint (with or without implementation) with a default error message (as a resource bundle).
h2. Constraint with no implementation
The following command will create a *constraint annotation* with no implementation, and a default *error message* :
{code}
constraint-new-annotation --named URL
{code}
This command first creates the constraint annotation (notice validatedBy = {})
{code}
@Documented
@Constraint(validatedBy = {})
@Target( { METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
@Retention(RUNTIME)
@ReportAsSingleViolation
public @interface URL {
String message() default "{org.mycompany.myproject.constraints.URL.message}";
Class<?>[] groups() default { };
Class<? extends Payload>[] payload() default { };
@Target( { METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
@Retention(RUNTIME)
@Documented
public @interface List {
URL[] value();
}
}
{code}
Then, it creates a message entry in the {{ValidationMessages.properties}} file (the file is created under {{resources}} directory if it doesn't already exist)
{code}
org.mycompany.myproject.constraints.URL.message=invalid URL
{code}
We could have attributes to the command to change the target
{code}
constraint-new-annotation --named URL --targets METHOD FIELD
{code}
This will generate the following code only with @Target METHOD, FIELD
{code}
@Documented
@Constraint(validatedBy = {})
@Target( { METHOD, FIELD })
@Retention(RUNTIME)
@ReportAsSingleViolation
public @interface URL {
String message() default "{org.mycompany.myproject.constraints.URL.message}";
Class<?>[] groups() default { };
Class<? extends Payload>[] payload() default { };
@Target( { METHOD, FIELD })
@Retention(RUNTIME)
@Documented
public @interface List {
URL[] value();
}
}
{code}
h2. Constraint with an implementation
The {{constraint-new-annotation}} can have a {{validatedBy}} and a {{type}} attribute, it will then create a *constraint annotation*, an *error message*, and a default *implementation* :
{code}
constraint-new-annotation --named URL --validatedBy URLValidator --type String
{code}
The constraint will now refer to the implementation class {{URLValidator.class}} :
{code}
@Documented
@Constraint(validatedBy = URLValidator.class)
@Target( { METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
@Retention(RUNTIME)
@ReportAsSingleViolation
public @interface URL {
String message() default "{org.mycompany.myproject.constraints.URL.message}";
Class<?>[] groups() default { };
Class<? extends Payload>[] payload() default { };
@Target( { METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
@Retention(RUNTIME)
@Documented
public @interface List {
URL[] value();
}
}
{code}
And the default implementation will look like :
{code}
public class URLValidator implements ConstraintValidator<URL, String> {
@Override
public void initialize(URL url) {
}
@Override
public boolean isValid(String value, ConstraintValidatorContext context) {
return false;
}
}
{code}
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira
12 years
[JBoss JIRA] (FORGE-1616) Command constraint-new-annotation to create a new constraint
by Antonio Goncalves (JIRA)
[ https://issues.jboss.org/browse/FORGE-1616?page=com.atlassian.jira.plugin... ]
Antonio Goncalves updated FORGE-1616:
-------------------------------------
Description:
The following command will create a *constraint annotation* with no implementation, and a default *error message* :
{code}
constraint-new-annotation --named URL
{code}
This command first creates the constraint annotation (notice validatedBy = {})
{code}
@Documented
@Constraint(validatedBy = {})
@Target( { METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
@Retention(RUNTIME)
@ReportAsSingleViolation
public @interface URL {
String message() default "Invalid value";
Class<?>[] groups() default { };
Class<? extends Payload>[] payload() default { };
@Target( { METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
@Retention(RUNTIME)
@Documented
public @interface List {
URL[] value();
}
}
{code}
was:
This allows the developer to create a constraint (with or without implementation) with a default error message (as a resource bundle).
h2. Constraint with no implementation
The following command will create a *constraint annotation* with no implementation, and a default *error message* :
{code}
constraint-new-annotation --named URL
{code}
This command first creates the constraint annotation (notice validatedBy = {})
{code}
@Documented
@Constraint(validatedBy = {})
@Target( { METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
@Retention(RUNTIME)
@ReportAsSingleViolation
public @interface URL {
String message() default "{org.mycompany.myproject.constraints.URL.message}";
Class<?>[] groups() default { };
Class<? extends Payload>[] payload() default { };
@Target( { METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
@Retention(RUNTIME)
@Documented
public @interface List {
URL[] value();
}
}
{code}
Then, it creates a message entry in the {{ValidationMessages.properties}} file (the file is created under {{resources}} directory if it doesn't already exist)
{code}
org.mycompany.myproject.constraints.URL.message=invalid URL
{code}
We could have attributes to the command to change the target
{code}
constraint-new-annotation --named URL --targets METHOD FIELD
{code}
This will generate the following code only with @Target METHOD, FIELD
{code}
@Documented
@Constraint(validatedBy = {})
@Target( { METHOD, FIELD })
@Retention(RUNTIME)
@ReportAsSingleViolation
public @interface URL {
String message() default "{org.mycompany.myproject.constraints.URL.message}";
Class<?>[] groups() default { };
Class<? extends Payload>[] payload() default { };
@Target( { METHOD, FIELD })
@Retention(RUNTIME)
@Documented
public @interface List {
URL[] value();
}
}
{code}
h2. Constraint with an implementation
The {{constraint-new-annotation}} can have a {{validatedBy}} and a {{type}} attribute, it will then create a *constraint annotation*, an *error message*, and a default *implementation* :
{code}
constraint-new-annotation --named URL --validatedBy URLValidator --type String
{code}
The constraint will now refer to the implementation class {{URLValidator.class}} :
{code}
@Documented
@Constraint(validatedBy = URLValidator.class)
@Target( { METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
@Retention(RUNTIME)
@ReportAsSingleViolation
public @interface URL {
String message() default "{org.mycompany.myproject.constraints.URL.message}";
Class<?>[] groups() default { };
Class<? extends Payload>[] payload() default { };
@Target( { METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
@Retention(RUNTIME)
@Documented
public @interface List {
URL[] value();
}
}
{code}
And the default implementation will look like :
{code}
public class URLValidator implements ConstraintValidator<URL, String> {
@Override
public void initialize(URL url) {
}
@Override
public boolean isValid(String value, ConstraintValidatorContext context) {
return false;
}
}
{code}
> Command constraint-new-annotation to create a new constraint
> ------------------------------------------------------------
>
> Key: FORGE-1616
> URL: https://issues.jboss.org/browse/FORGE-1616
> Project: Forge
> Issue Type: Sub-task
> Components: Java EE
> Affects Versions: 2.1.1.Final
> Reporter: Antonio Goncalves
> Assignee: Antonio Goncalves
> Labels: Starter
> Fix For: 2.x Future
>
>
> The following command will create a *constraint annotation* with no implementation, and a default *error message* :
> {code}
> constraint-new-annotation --named URL
> {code}
> This command first creates the constraint annotation (notice validatedBy = {})
> {code}
> @Documented
> @Constraint(validatedBy = {})
> @Target( { METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
> @Retention(RUNTIME)
> @ReportAsSingleViolation
> public @interface URL {
> String message() default "Invalid value";
> Class<?>[] groups() default { };
> Class<? extends Payload>[] payload() default { };
> @Target( { METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
> @Retention(RUNTIME)
> @Documented
> public @interface List {
> URL[] value();
> }
> }
> {code}
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira
12 years
[JBoss JIRA] (FORGE-1616) Command constraint-new-annotation to create a new constraint
by Antonio Goncalves (JIRA)
[ https://issues.jboss.org/browse/FORGE-1616?page=com.atlassian.jira.plugin... ]
Antonio Goncalves reassigned FORGE-1616:
----------------------------------------
Assignee: Antonio Goncalves
> Command constraint-new-annotation to create a new constraint
> ------------------------------------------------------------
>
> Key: FORGE-1616
> URL: https://issues.jboss.org/browse/FORGE-1616
> Project: Forge
> Issue Type: Sub-task
> Components: Java EE
> Affects Versions: 2.1.1.Final
> Reporter: Antonio Goncalves
> Assignee: Antonio Goncalves
> Labels: Starter
> Fix For: 2.x Future
>
>
> This allows the developer to create a constraint (with or without implementation) with a default error message (as a resource bundle).
> h2. Constraint with no implementation
> The following command will create a *constraint annotation* with no implementation, and a default *error message* :
> {code}
> constraint-new-annotation --named URL
> {code}
> This command first creates the constraint annotation (notice validatedBy = {})
> {code}
> @Documented
> @Constraint(validatedBy = {})
> @Target( { METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
> @Retention(RUNTIME)
> @ReportAsSingleViolation
> public @interface URL {
> String message() default "{org.mycompany.myproject.constraints.URL.message}";
> Class<?>[] groups() default { };
> Class<? extends Payload>[] payload() default { };
> @Target( { METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
> @Retention(RUNTIME)
> @Documented
> public @interface List {
> URL[] value();
> }
> }
> {code}
> Then, it creates a message entry in the {{ValidationMessages.properties}} file (the file is created under {{resources}} directory if it doesn't already exist)
> {code}
> org.mycompany.myproject.constraints.URL.message=invalid URL
> {code}
> We could have attributes to the command to change the target
> {code}
> constraint-new-annotation --named URL --targets METHOD FIELD
> {code}
> This will generate the following code only with @Target METHOD, FIELD
> {code}
> @Documented
> @Constraint(validatedBy = {})
> @Target( { METHOD, FIELD })
> @Retention(RUNTIME)
> @ReportAsSingleViolation
> public @interface URL {
> String message() default "{org.mycompany.myproject.constraints.URL.message}";
> Class<?>[] groups() default { };
> Class<? extends Payload>[] payload() default { };
> @Target( { METHOD, FIELD })
> @Retention(RUNTIME)
> @Documented
> public @interface List {
> URL[] value();
> }
> }
> {code}
>
> h2. Constraint with an implementation
> The {{constraint-new-annotation}} can have a {{validatedBy}} and a {{type}} attribute, it will then create a *constraint annotation*, an *error message*, and a default *implementation* :
> {code}
> constraint-new-annotation --named URL --validatedBy URLValidator --type String
> {code}
> The constraint will now refer to the implementation class {{URLValidator.class}} :
> {code}
> @Documented
> @Constraint(validatedBy = URLValidator.class)
> @Target( { METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
> @Retention(RUNTIME)
> @ReportAsSingleViolation
> public @interface URL {
> String message() default "{org.mycompany.myproject.constraints.URL.message}";
> Class<?>[] groups() default { };
> Class<? extends Payload>[] payload() default { };
> @Target( { METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
> @Retention(RUNTIME)
> @Documented
> public @interface List {
> URL[] value();
> }
> }
> {code}
> And the default implementation will look like :
> {code}
> public class URLValidator implements ConstraintValidator<URL, String> {
> @Override
> public void initialize(URL url) {
> }
> @Override
> public boolean isValid(String value, ConstraintValidatorContext context) {
> return false;
> }
> }
> {code}
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira
12 years
[JBoss JIRA] (FORGE-1616) Command constraint-new-annotation to create a new constraint
by Antonio Goncalves (JIRA)
[ https://issues.jboss.org/browse/FORGE-1616?page=com.atlassian.jira.plugin... ]
Antonio Goncalves updated FORGE-1616:
-------------------------------------
Description:
This allows the developer to create a constraint (with or without implementation) with a default error message (as a resource bundle).
h2. Constraint with no implementation
The following command will create a *constraint annotation* with no implementation, and a default *error message* :
{code}
constraint-new-annotation --named URL
{code}
This command first creates the constraint annotation (notice validatedBy = {})
{code}
@Documented
@Constraint(validatedBy = {})
@Target( { METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
@Retention(RUNTIME)
@ReportAsSingleViolation
public @interface URL {
String message() default "{org.mycompany.myproject.constraints.URL.message}";
Class<?>[] groups() default { };
Class<? extends Payload>[] payload() default { };
@Target( { METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
@Retention(RUNTIME)
@Documented
public @interface List {
URL[] value();
}
}
{code}
Then, it creates a message entry in the {{ValidationMessages.properties}} file (the file is created under {{resources}} directory if it doesn't already exist)
{code}
org.mycompany.myproject.constraints.URL.message=invalid URL
{code}
We could have attributes to the command to change the target
{code}
constraint-new-annotation --named URL --targets METHOD FIELD
{code}
This will generate the following code only with @Target METHOD, FIELD
{code}
@Documented
@Constraint(validatedBy = {})
@Target( { METHOD, FIELD })
@Retention(RUNTIME)
@ReportAsSingleViolation
public @interface URL {
String message() default "{org.mycompany.myproject.constraints.URL.message}";
Class<?>[] groups() default { };
Class<? extends Payload>[] payload() default { };
@Target( { METHOD, FIELD })
@Retention(RUNTIME)
@Documented
public @interface List {
URL[] value();
}
}
{code}
h2. Constraint with an implementation
The {{constraint-new-annotation}} can have a {{validatedBy}} and a {{type}} attribute, it will then create a *constraint annotation*, an *error message*, and a default *implementation* :
{code}
constraint-new-annotation --named URL --validatedBy URLValidator --type String
{code}
The constraint will now refer to the implementation class {{URLValidator.class}} :
{code}
@Documented
@Constraint(validatedBy = URLValidator.class)
@Target( { METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
@Retention(RUNTIME)
@ReportAsSingleViolation
public @interface URL {
String message() default "{org.mycompany.myproject.constraints.URL.message}";
Class<?>[] groups() default { };
Class<? extends Payload>[] payload() default { };
@Target( { METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
@Retention(RUNTIME)
@Documented
public @interface List {
URL[] value();
}
}
{code}
And the default implementation will look like :
{code}
public class URLValidator implements ConstraintValidator<URL, String> {
@Override
public void initialize(URL url) {
}
@Override
public boolean isValid(String value, ConstraintValidatorContext context) {
return false;
}
}
{code}
was:
This allows the developer to create a constraint (with or without implementation) with a default error message (as a resource bundle).
h2. Constraint with no implementation
The following command will create a *constraint annotation* with no implementation, and a default *error message* :
{code}
constraint-new-constraint --named URL
{code}
This command first creates the constraint annotation (notice validatedBy = {})
{code}
@Documented
@Constraint(validatedBy = {})
@Target( { METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
@Retention(RUNTIME)
@ReportAsSingleViolation
public @interface URL {
String message() default "{org.mycompany.myproject.constraints.URL.message}";
Class<?>[] groups() default { };
Class<? extends Payload>[] payload() default { };
@Target( { METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
@Retention(RUNTIME)
@Documented
public @interface List {
URL[] value();
}
}
{code}
Then, it creates a message entry in the {{ValidationMessages.properties}} file (the file is created under {{resources}} directory if it doesn't already exist)
{code}
org.mycompany.myproject.constraints.URL.message=invalid URL
{code}
We could have attributes to the command to change the target
{code}
constraint-new-constraint --named URL --targets METHOD FIELD
{code}
This will generate the following code only with @Target METHOD, FIELD
{code}
@Documented
@Constraint(validatedBy = {})
@Target( { METHOD, FIELD })
@Retention(RUNTIME)
@ReportAsSingleViolation
public @interface URL {
String message() default "{org.mycompany.myproject.constraints.URL.message}";
Class<?>[] groups() default { };
Class<? extends Payload>[] payload() default { };
@Target( { METHOD, FIELD })
@Retention(RUNTIME)
@Documented
public @interface List {
URL[] value();
}
}
{code}
h2. Constraint with an implementation
The {{constraint-new-constraint}} can have a {{validatedBy}} and a {{type}} attribute, it will then create a *constraint annotation*, an *error message*, and a default *implementation* :
{code}
constraint-new-constraint --named URL --validatedBy URLValidator --type String
{code}
The constraint will now refer to the implementation class {{URLValidator.class}} :
{code}
@Documented
@Constraint(validatedBy = URLValidator.class)
@Target( { METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
@Retention(RUNTIME)
@ReportAsSingleViolation
public @interface URL {
String message() default "{org.mycompany.myproject.constraints.URL.message}";
Class<?>[] groups() default { };
Class<? extends Payload>[] payload() default { };
@Target( { METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
@Retention(RUNTIME)
@Documented
public @interface List {
URL[] value();
}
}
{code}
And the default implementation will look like :
{code}
public class URLValidator implements ConstraintValidator<URL, String> {
@Override
public void initialize(URL url) {
}
@Override
public boolean isValid(String value, ConstraintValidatorContext context) {
return false;
}
}
{code}
> Command constraint-new-annotation to create a new constraint
> ------------------------------------------------------------
>
> Key: FORGE-1616
> URL: https://issues.jboss.org/browse/FORGE-1616
> Project: Forge
> Issue Type: Sub-task
> Components: Java EE
> Affects Versions: 2.1.1.Final
> Reporter: Antonio Goncalves
> Labels: Starter
> Fix For: 2.x Future
>
>
> This allows the developer to create a constraint (with or without implementation) with a default error message (as a resource bundle).
> h2. Constraint with no implementation
> The following command will create a *constraint annotation* with no implementation, and a default *error message* :
> {code}
> constraint-new-annotation --named URL
> {code}
> This command first creates the constraint annotation (notice validatedBy = {})
> {code}
> @Documented
> @Constraint(validatedBy = {})
> @Target( { METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
> @Retention(RUNTIME)
> @ReportAsSingleViolation
> public @interface URL {
> String message() default "{org.mycompany.myproject.constraints.URL.message}";
> Class<?>[] groups() default { };
> Class<? extends Payload>[] payload() default { };
> @Target( { METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
> @Retention(RUNTIME)
> @Documented
> public @interface List {
> URL[] value();
> }
> }
> {code}
> Then, it creates a message entry in the {{ValidationMessages.properties}} file (the file is created under {{resources}} directory if it doesn't already exist)
> {code}
> org.mycompany.myproject.constraints.URL.message=invalid URL
> {code}
> We could have attributes to the command to change the target
> {code}
> constraint-new-annotation --named URL --targets METHOD FIELD
> {code}
> This will generate the following code only with @Target METHOD, FIELD
> {code}
> @Documented
> @Constraint(validatedBy = {})
> @Target( { METHOD, FIELD })
> @Retention(RUNTIME)
> @ReportAsSingleViolation
> public @interface URL {
> String message() default "{org.mycompany.myproject.constraints.URL.message}";
> Class<?>[] groups() default { };
> Class<? extends Payload>[] payload() default { };
> @Target( { METHOD, FIELD })
> @Retention(RUNTIME)
> @Documented
> public @interface List {
> URL[] value();
> }
> }
> {code}
>
> h2. Constraint with an implementation
> The {{constraint-new-annotation}} can have a {{validatedBy}} and a {{type}} attribute, it will then create a *constraint annotation*, an *error message*, and a default *implementation* :
> {code}
> constraint-new-annotation --named URL --validatedBy URLValidator --type String
> {code}
> The constraint will now refer to the implementation class {{URLValidator.class}} :
> {code}
> @Documented
> @Constraint(validatedBy = URLValidator.class)
> @Target( { METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
> @Retention(RUNTIME)
> @ReportAsSingleViolation
> public @interface URL {
> String message() default "{org.mycompany.myproject.constraints.URL.message}";
> Class<?>[] groups() default { };
> Class<? extends Payload>[] payload() default { };
> @Target( { METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
> @Retention(RUNTIME)
> @Documented
> public @interface List {
> URL[] value();
> }
> }
> {code}
> And the default implementation will look like :
> {code}
> public class URLValidator implements ConstraintValidator<URL, String> {
> @Override
> public void initialize(URL url) {
> }
> @Override
> public boolean isValid(String value, ConstraintValidatorContext context) {
> return false;
> }
> }
> {code}
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira
12 years
[JBoss JIRA] (FORGE-1616) Command constraint-new-annotation to create a new constraint
by Antonio Goncalves (JIRA)
[ https://issues.jboss.org/browse/FORGE-1616?page=com.atlassian.jira.plugin... ]
Antonio Goncalves updated FORGE-1616:
-------------------------------------
Summary: Command constraint-new-annotation to create a new constraint (was: Command constraint-new-constraint to create a new constraint)
> Command constraint-new-annotation to create a new constraint
> ------------------------------------------------------------
>
> Key: FORGE-1616
> URL: https://issues.jboss.org/browse/FORGE-1616
> Project: Forge
> Issue Type: Sub-task
> Components: Java EE
> Affects Versions: 2.1.1.Final
> Reporter: Antonio Goncalves
> Labels: Starter
> Fix For: 2.x Future
>
>
> This allows the developer to create a constraint (with or without implementation) with a default error message (as a resource bundle).
> h2. Constraint with no implementation
> The following command will create a *constraint annotation* with no implementation, and a default *error message* :
> {code}
> constraint-new-constraint --named URL
> {code}
> This command first creates the constraint annotation (notice validatedBy = {})
> {code}
> @Documented
> @Constraint(validatedBy = {})
> @Target( { METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
> @Retention(RUNTIME)
> @ReportAsSingleViolation
> public @interface URL {
> String message() default "{org.mycompany.myproject.constraints.URL.message}";
> Class<?>[] groups() default { };
> Class<? extends Payload>[] payload() default { };
> @Target( { METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
> @Retention(RUNTIME)
> @Documented
> public @interface List {
> URL[] value();
> }
> }
> {code}
> Then, it creates a message entry in the {{ValidationMessages.properties}} file (the file is created under {{resources}} directory if it doesn't already exist)
> {code}
> org.mycompany.myproject.constraints.URL.message=invalid URL
> {code}
> We could have attributes to the command to change the target
> {code}
> constraint-new-constraint --named URL --targets METHOD FIELD
> {code}
> This will generate the following code only with @Target METHOD, FIELD
> {code}
> @Documented
> @Constraint(validatedBy = {})
> @Target( { METHOD, FIELD })
> @Retention(RUNTIME)
> @ReportAsSingleViolation
> public @interface URL {
> String message() default "{org.mycompany.myproject.constraints.URL.message}";
> Class<?>[] groups() default { };
> Class<? extends Payload>[] payload() default { };
> @Target( { METHOD, FIELD })
> @Retention(RUNTIME)
> @Documented
> public @interface List {
> URL[] value();
> }
> }
> {code}
>
> h2. Constraint with an implementation
> The {{constraint-new-constraint}} can have a {{validatedBy}} and a {{type}} attribute, it will then create a *constraint annotation*, an *error message*, and a default *implementation* :
> {code}
> constraint-new-constraint --named URL --validatedBy URLValidator --type String
> {code}
> The constraint will now refer to the implementation class {{URLValidator.class}} :
> {code}
> @Documented
> @Constraint(validatedBy = URLValidator.class)
> @Target( { METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
> @Retention(RUNTIME)
> @ReportAsSingleViolation
> public @interface URL {
> String message() default "{org.mycompany.myproject.constraints.URL.message}";
> Class<?>[] groups() default { };
> Class<? extends Payload>[] payload() default { };
> @Target( { METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
> @Retention(RUNTIME)
> @Documented
> public @interface List {
> URL[] value();
> }
> }
> {code}
> And the default implementation will look like :
> {code}
> public class URLValidator implements ConstraintValidator<URL, String> {
> @Override
> public void initialize(URL url) {
> }
> @Override
> public boolean isValid(String value, ConstraintValidatorContext context) {
> return false;
> }
> }
> {code}
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira
12 years
[JBoss JIRA] (FORGE-1666) Add BOM to new addon projects
by George Gastaldi (JIRA)
George Gastaldi created FORGE-1666:
--------------------------------------
Summary: Add BOM to new addon projects
Key: FORGE-1666
URL: https://issues.jboss.org/browse/FORGE-1666
Project: Forge
Issue Type: Enhancement
Components: Addon Development
Affects Versions: 2.1.1.Final
Reporter: George Gastaldi
Fix For: 2.x Future
{{Project:New}} of type {{Forge Addon}} should add the BOM as a managed imported scope:
- in the addon project when using the simple layout
- in the parent project of the addon when using the complex layout
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira
12 years
[JBoss JIRA] (FORGE-1665) Create a BOM project located at forge/core/bom
by Lincoln Baxter III (JIRA)
Lincoln Baxter III created FORGE-1665:
-----------------------------------------
Summary: Create a BOM project located at forge/core/bom
Key: FORGE-1665
URL: https://issues.jboss.org/browse/FORGE-1665
Project: Forge
Issue Type: Feature Request
Components: Forge Build
Affects Versions: 2.1.1.Final
Reporter: Lincoln Baxter III
Fix For: 2.x Future
This BOM should specify versions for Furnace and all of the built-in Forge addons. The Forge Parent should include this BOM instead of specifying its own versions for these dependencies.
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira
12 years