diff options
10 files changed, 996 insertions, 179 deletions
diff --git a/common-parameters/pom.xml b/common-parameters/pom.xml index c7136bd3..c0efcf70 100644 --- a/common-parameters/pom.xml +++ b/common-parameters/pom.xml @@ -31,6 +31,10 @@ <description>[${project.parent.artifactId}] module provides common property and parameter handling the ONAP Policy Framework</description> <dependencies> + <dependency> + <groupId>com.google.re2j</groupId> + <artifactId>re2j</artifactId> + </dependency> <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-lang3</artifactId> diff --git a/common-parameters/src/main/java/org/onap/policy/common/parameters/BeanValidator.java b/common-parameters/src/main/java/org/onap/policy/common/parameters/BeanValidator.java index dbd3c7ce..3f5abccc 100644 --- a/common-parameters/src/main/java/org/onap/policy/common/parameters/BeanValidator.java +++ b/common-parameters/src/main/java/org/onap/policy/common/parameters/BeanValidator.java @@ -22,33 +22,25 @@ package org.onap.policy.common.parameters; import java.lang.annotation.Annotation; import java.lang.reflect.Field; -import java.lang.reflect.InvocationTargetException; -import java.lang.reflect.Method; -import java.lang.reflect.Modifier; -import java.util.ArrayList; -import java.util.List; -import java.util.function.BiPredicate; -import java.util.function.Predicate; +import java.util.Collection; +import java.util.Map; +import java.util.Map.Entry; import org.apache.commons.lang3.StringUtils; +import org.onap.policy.common.parameters.annotations.Entries; +import org.onap.policy.common.parameters.annotations.Items; import org.onap.policy.common.parameters.annotations.Max; import org.onap.policy.common.parameters.annotations.Min; import org.onap.policy.common.parameters.annotations.NotBlank; import org.onap.policy.common.parameters.annotations.NotNull; +import org.onap.policy.common.parameters.annotations.Pattern; +import org.onap.policy.common.parameters.annotations.Valid; /** * Bean validator, supporting the parameter annotations. - * <p/> - * Note: this currently does not support Min/Max validation of "short" or "byte"; these - * annotations are simply ignored for these types. */ public class BeanValidator { /** - * {@code True} if there is a field-level annotation, {@code false} otherwise. - */ - private boolean fieldIsAnnotated; - - /** * Validates top level fields within an object. For each annotated field, it retrieves * the value using the public "getter" method for the field. If there is no public * "getter" method, then it throws an exception. Otherwise, it validates the retrieved @@ -75,162 +67,95 @@ public class BeanValidator { } /** - * Performs validation of all annotated fields found within the class. + * Adds validators based on the annotations that are available. * - * @param result validation results are added here - * @param object object whose fields are to be validated - * @param clazz class, within the object's hierarchy, to be examined for fields to be - * verified + * @param validator where to add the validators */ - private void validateFields(BeanValidationResult result, Object object, Class<?> clazz) { - for (Field field : clazz.getDeclaredFields()) { - validateField(result, object, clazz, field); - } + protected void addValidators(ValueValidator validator) { + validator.addAnnotation(NotNull.class, this::verNotNull); + validator.addAnnotation(NotBlank.class, this::verNotBlank); + validator.addAnnotation(Max.class, this::verMax); + validator.addAnnotation(Min.class, this::verMin); + validator.addAnnotation(Pattern.class, this::verRegex); + validator.addAnnotation(Valid.class, this::verCascade); + validator.addAnnotation(Items.class, this::verCollection); + validator.addAnnotation(Entries.class, this::verMap); } /** - * Performs validation of a single field. + * Performs validation of all annotated fields found within the class. * * @param result validation results are added here * @param object object whose fields are to be validated - * @param clazz class, within the object's hierarchy, containing the field - * @param field field whose value is to be validated - */ - private void validateField(BeanValidationResult result, Object object, Class<?> clazz, Field field) { - final String fieldName = field.getName(); - if (fieldName.contains("$")) { - return; - } - - /* - * Identify the annotations. NotNull MUST be first so the check is run before the - * others. - */ - fieldIsAnnotated = false; - List<Predicate<Object>> checkers = new ArrayList<>(10); - addAnnotation(clazz, field, checkers, NotNull.class, (annot, value) -> verNotNull(result, fieldName, value)); - addAnnotation(clazz, field, checkers, NotBlank.class, (annot, value) -> verNotBlank(result, fieldName, value)); - addAnnotation(clazz, field, checkers, Max.class, (annot, value) -> verMax(result, fieldName, annot, value)); - addAnnotation(clazz, field, checkers, Min.class, (annot, value) -> verMin(result, fieldName, annot, value)); - - if (checkers.isEmpty()) { - // has no annotations - nothing to check - return; - } - - // verify the field type is of interest - int mod = field.getModifiers(); - if (Modifier.isStatic(mod)) { - classOnly(clazz.getName() + "." + fieldName + " is annotated but the field is static"); - return; - } - - // get the field's "getter" method - Method accessor = getAccessor(object.getClass(), fieldName); - if (accessor == null) { - classOnly(clazz.getName() + "." + fieldName + " is annotated but has no \"get\" method"); - return; - } - - // get the value - Object value = getValue(object, clazz, fieldName, accessor); - - // perform the checks - if (value == null && field.getAnnotation(NotNull.class) == null && clazz.getAnnotation(NotNull.class) == null) { - // value is null and there's no null check - just return - return; - } - - for (Predicate<Object> checker : checkers) { - if (!checker.test(value)) { - // invalid - don't bother with additional checks - return; - } - } - } - - /** - * Gets the value from the object using the accessor function. - * - * @param object object whose value is to be retrieved - * @param clazz class containing the field - * @param fieldName name of the field - * @param accessor "getter" method - * @return the object's value - */ - private Object getValue(Object object, Class<?> clazz, final String fieldName, Method accessor) { - try { - return accessor.invoke(object); - - } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { - throw new IllegalArgumentException(clazz.getName() + "." + fieldName + " accessor threw an exception", e); - } - } - - /** - * Throws an exception if there are field-level annotations. - * - * @param exceptionMessage exception message + * @param clazz class, within the object's hierarchy, to be examined for fields to be + * verified */ - private void classOnly(String exceptionMessage) { - if (fieldIsAnnotated) { - throw new IllegalArgumentException(exceptionMessage); + private void validateFields(BeanValidationResult result, Object object, Class<?> clazz) { + for (Field field : clazz.getDeclaredFields()) { + FieldValidator validator = makeFieldValidator(clazz, field); + validator.validateField(result, object); } } /** - * Looks for an annotation at the class or field level. If an annotation is found at - * either the field or class level, then it adds a verifier to the list of checkers. + * Verifies that the value is not null. * - * @param clazz class to be searched - * @param field field to be searched - * @param checkers where to place the new field verifier - * @param annotClass class of annotation to find - * @param check verification function to be added to the list, if the annotation is - * found + * @param result where to add the validation result + * @param fieldName field whose value is being verified + * @param value value to be verified + * @return {@code true} if the next check should be performed, {@code false} otherwise */ - private <T extends Annotation> void addAnnotation(Class<?> clazz, Field field, List<Predicate<Object>> checkers, - Class<T> annotClass, BiPredicate<T, Object> check) { - - // field annotation takes precedence over class annotation - T annot = field.getAnnotation(annotClass); - if (annot != null) { - fieldIsAnnotated = true; - - } else if ((annot = clazz.getAnnotation(annotClass)) == null) { - return; + public boolean verNotNull(BeanValidationResult result, String fieldName, Object value) { + if (value == null) { + ObjectValidationResult result2 = + new ObjectValidationResult(fieldName, xlate(value), ValidationStatus.INVALID, "is null"); + result.addResult(result2); + return false; } - T annot2 = annot; - checkers.add(value -> check.test(annot2, value)); + return true; } /** - * Verifies that the value is not null. + * Verifies that the value is not blank. Note: this does <i>not</i> verify that the + * value is not {@code null}. * * @param result where to add the validation result * @param fieldName field whose value is being verified - * @param value value to be verified, assumed to be non-null - * @return {@code true} if the value is valid, {@code false} otherwise + * @param value value to be verified + * @return {@code true} if the next check should be performed, {@code false} otherwise */ - private boolean verNotNull(BeanValidationResult result, String fieldName, Object value) { - return result.validateNotNull(fieldName, value); + public boolean verNotBlank(BeanValidationResult result, String fieldName, Object value) { + if (value instanceof String && StringUtils.isBlank(value.toString())) { + ObjectValidationResult result2 = + new ObjectValidationResult(fieldName, xlate(value), ValidationStatus.INVALID, "is blank"); + result.addResult(result2); + return false; + } + + return true; } /** - * Verifies that the value is not blank. + * Verifies that the value matches a regular expression. * * @param result where to add the validation result * @param fieldName field whose value is being verified - * @param value value to be verified, assumed to be non-null - * @return {@code true} if the value is valid, {@code false} otherwise + * @param annot annotation against which the value is being verified + * @param value value to be verified + * @return {@code true} if the next check should be performed, {@code false} otherwise */ - private boolean verNotBlank(BeanValidationResult result, String fieldName, Object value) { - if (value instanceof String && StringUtils.isBlank(value.toString())) { - ObjectValidationResult fieldResult = - new ObjectValidationResult(fieldName, value, ValidationStatus.INVALID, "is blank"); - result.addResult(fieldResult); - return false; + public boolean verRegex(BeanValidationResult result, String fieldName, Pattern annot, Object value) { + try { + if (value instanceof String && !com.google.re2j.Pattern.matches(annot.regexp(), value.toString())) { + ObjectValidationResult result2 = new ObjectValidationResult(fieldName, xlate(value), + ValidationStatus.INVALID, "does not match regular expression " + annot.regexp()); + result.addResult(result2); + return false; + } + } catch (RuntimeException e) { + // TODO log at trace level + return true; } return true; @@ -242,10 +167,10 @@ public class BeanValidator { * @param result where to add the validation result * @param fieldName field whose value is being verified * @param annot annotation against which the value is being verified - * @param value value to be verified, assumed to be non-null - * @return {@code true} if the value is valid, {@code false} otherwise + * @param value value to be verified + * @return {@code true} if the next check should be performed, {@code false} otherwise */ - private boolean verMax(BeanValidationResult result, String fieldName, Max annot, Object value) { + public boolean verMax(BeanValidationResult result, String fieldName, Max annot, Object value) { if (!(value instanceof Number)) { return true; } @@ -265,9 +190,9 @@ public class BeanValidator { return true; } - ObjectValidationResult fieldResult = new ObjectValidationResult(fieldName, value, ValidationStatus.INVALID, + ObjectValidationResult result2 = new ObjectValidationResult(fieldName, xlate(value), ValidationStatus.INVALID, "exceeds the maximum value: " + annot.value()); - result.addResult(fieldResult); + result.addResult(result2); return false; } @@ -277,22 +202,35 @@ public class BeanValidator { * @param result where to add the validation result * @param fieldName field whose value is being verified * @param annot annotation against which the value is being verified - * @param value value to be verified, assumed to be non-null - * @return {@code true} if the value is valid, {@code false} otherwise + * @param value value to be verified + * @return {@code true} if the next check should be performed, {@code false} otherwise + */ + public boolean verMin(BeanValidationResult result, String fieldName, Min annot, Object value) { + return verMin(result, fieldName, annot.value(), value); + } + + /** + * Verifies that the value is >= the minimum value. + * + * @param result where to add the validation result + * @param fieldName field whose value is being verified + * @param min minimum against which the value is being verified + * @param value value to be verified + * @return {@code true} if the next check should be performed, {@code false} otherwise */ - private boolean verMin(BeanValidationResult result, String fieldName, Min annot, Object value) { + public boolean verMin(BeanValidationResult result, String fieldName, long min, Object value) { if (!(value instanceof Number)) { return true; } Number num = (Number) value; if (num instanceof Integer || num instanceof Long) { - if (num.longValue() >= annot.value()) { + if (num.longValue() >= min) { return true; } } else if (num instanceof Float || num instanceof Double) { - if (num.doubleValue() >= annot.value()) { + if (num.doubleValue() >= min) { return true; } @@ -300,54 +238,181 @@ public class BeanValidator { return true; } - ObjectValidationResult fieldResult = new ObjectValidationResult(fieldName, value, ValidationStatus.INVALID, - "is below the minimum value: " + annot.value()); - result.addResult(fieldResult); + ObjectValidationResult result2 = new ObjectValidationResult(fieldName, xlate(value), ValidationStatus.INVALID, + "is below the minimum value: " + min); + result.addResult(result2); return false; } /** - * Gets an accessor method for the given field. + * Verifies that the value is valid by recursively invoking + * {@link #validateTop(String, Object)}. * - * @param clazz class whose methods are to be searched - * @param fieldName field whose "getter" is to be identified - * @return the field's "getter" method, or {@code null} if it is not found + * @param result where to add the validation result + * @param fieldName field whose value is being verified + * @param value value to be verified + * @return {@code true} if the next check should be performed, {@code false} otherwise */ - private Method getAccessor(Class<?> clazz, String fieldName) { - String capname = StringUtils.capitalize(fieldName); - Method accessor = getMethod(clazz, "get" + capname); - if (accessor != null) { - return accessor; + public boolean verCascade(BeanValidationResult result, String fieldName, Object value) { + if (value == null || value instanceof Collection || value instanceof Map) { + return true; } - return getMethod(clazz, "is" + capname); + BeanValidationResult result2 = validateTop(fieldName, value); + + if (result2.isClean()) { + return true; + } + + result.addResult(result2); + + return result2.isValid(); } /** - * Gets the "getter" method having the specified name. + * Validates the items in a collection. * - * @param clazz class whose methods are to be searched - * @param methodName name of the method of interest - * @return the method, or {@code null} if it is not found + * @param result where to add the validation result + * @param fieldName name of the field containing the collection + * @param annot validation annotations for individual items + * @param value value to be verified + * @return {@code true} if the next check should be performed, {@code false} otherwise */ - private Method getMethod(Class<?> clazz, String methodName) { - for (Method method : clazz.getMethods()) { - if (methodName.equals(method.getName()) && validMethod(method)) { - return method; - } + public boolean verCollection(BeanValidationResult result, String fieldName, Annotation annot, Object value) { + + if (!(value instanceof Collection)) { + return true; + } + + ItemValidator itemValidator = makeItemValidator(annot); + + return verCollection(result, fieldName, itemValidator, value); + } + + /** + * Validates the items in a collection. + * + * @param result where to add the validation result + * @param fieldName name of the field containing the collection + * @param itemValidator validator for individual items within the list + * @param value value to be verified + * @return {@code true} if the next check should be performed, {@code false} otherwise + */ + public boolean verCollection(BeanValidationResult result, String fieldName, ValueValidator itemValidator, + Object value) { + + if (!(value instanceof Collection) || itemValidator.isEmpty()) { + return true; + } + + Collection<?> list = (Collection<?>) value; + + BeanValidationResult result2 = new BeanValidationResult(fieldName, value); + int count = 0; + for (Object item : list) { + itemValidator.validateValue(result2, String.valueOf(count++), item); + } + + if (result2.isClean()) { + return true; + } + + result.addResult(result2); + return false; + } + + /** + * Validates the items in a Map. + * + * @param result where to add the validation result + * @param fieldName name of the field containing the map + * @param annot validation annotations for individual entries + * @param value value to be verified + * @return {@code true} if the next check should be performed, {@code false} otherwise + */ + public boolean verMap(BeanValidationResult result, String fieldName, Entries annot, Object value) { + + if (!(value instanceof Map)) { + return true; + } + + EntryValidator entryValidator = makeEntryValidator(annot.key(), annot.value()); + + return verMap(result, fieldName, entryValidator, value); + } + + /** + * Validates the items in a Map. + * + * @param result where to add the validation result + * @param fieldName name of the field containing the map + * @param entryValidator validator for individual entries within the Map + * @param value value to be verified + * @return {@code true} if the next check should be performed, {@code false} otherwise + */ + public boolean verMap(BeanValidationResult result, String fieldName, EntryValidator entryValidator, Object value) { + + if (!(value instanceof Map)) { + return true; + } + + Map<?, ?> map = (Map<?, ?>) value; + + BeanValidationResult result2 = new BeanValidationResult(fieldName, value); + + for (Entry<?, ?> entry : map.entrySet()) { + entryValidator.validateEntry(result2, entry); + } + + if (result2.isClean()) { + return true; } - return null; + result.addResult(result2); + return false; + } + + /** + * Makes a field validator. + * + * @param clazz class containing the field + * @param field field of interest + * @return a validator for the given field + */ + protected FieldValidator makeFieldValidator(Class<?> clazz, Field field) { + return new FieldValidator(this, clazz, field); + } + + /** + * Makes an item validator. + * + * @param annot container for the item annotations + * @return a new item validator + */ + protected ItemValidator makeItemValidator(Annotation annot) { + return new ItemValidator(this, annot); + } + + /** + * Makes an entry validator. + * + * @param keyAnnot container for the annotations associated with the entry key + * @param valueAnnot container for the annotations associated with the entry value + * @return a new entry validator + */ + protected EntryValidator makeEntryValidator(Annotation keyAnnot, Annotation valueAnnot) { + return new EntryValidator(this, keyAnnot, valueAnnot); } /** - * Determines if a method is a valid "getter". + * Translates a value to something printable, for use by + * {@link ObjectValidationResult}. This default method simply returns the original + * value. * - * @param method method to be checked - * @return {@code true} if the method is a valid "getter", {@code false} otherwise + * @param value value to be translated + * @return the translated value */ - private boolean validMethod(Method method) { - int mod = method.getModifiers(); - return !(Modifier.isStatic(mod) || method.getReturnType() == void.class || method.getParameterCount() != 0); + public Object xlate(Object value) { + return value; } } diff --git a/common-parameters/src/main/java/org/onap/policy/common/parameters/EntryValidator.java b/common-parameters/src/main/java/org/onap/policy/common/parameters/EntryValidator.java new file mode 100644 index 00000000..965c95e5 --- /dev/null +++ b/common-parameters/src/main/java/org/onap/policy/common/parameters/EntryValidator.java @@ -0,0 +1,84 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP + * ================================================================================ + * Copyright (C) 2020 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.common.parameters; + +import java.lang.annotation.Annotation; +import java.util.Map; + +/** + * Validator of an entry within a Map. + */ +public class EntryValidator { + private final ItemValidator keyValidator; + private final ItemValidator valueValidator; + + /** + * Constructs the object. + * + * @param validator provider of validation methods + * @param keyAnnotationContainer an annotation containing validation annotations to be + * applied to the entry key + * @param valueAnnotationContainer an annotation containing validation annotations to + * be applied to the entry value + */ + public EntryValidator(BeanValidator validator, Annotation keyAnnotationContainer, + Annotation valueAnnotationContainer) { + keyValidator = new ItemValidator(validator, keyAnnotationContainer); + valueValidator = new ItemValidator(validator, valueAnnotationContainer); + } + + public boolean isEmpty() { + return (keyValidator.isEmpty() && valueValidator.isEmpty()); + } + + /** + * Performs validation of a single entry. + * + * @param result validation results are added here + * @param entry value to be validated + */ + public <K, V> void validateEntry(BeanValidationResult result, Map.Entry<K, V> entry) { + String name = getName(entry); + + BeanValidationResult result2 = new BeanValidationResult(name, entry); + keyValidator.validateValue(result2, "key", entry.getKey()); + valueValidator.validateValue(result2, "value", entry.getValue()); + + if (!result2.isClean()) { + result.addResult(result2); + } + } + + /** + * Gets a name for the entry. + * + * @param entry entry whose name is to be determined + * @return a name for the entry + */ + protected <K, V> String getName(Map.Entry<K, V> entry) { + K key = entry.getKey(); + if (key == null) { + return ""; + } + + return key.toString(); + } +} diff --git a/common-parameters/src/main/java/org/onap/policy/common/parameters/FieldValidator.java b/common-parameters/src/main/java/org/onap/policy/common/parameters/FieldValidator.java new file mode 100644 index 00000000..e762dc0e --- /dev/null +++ b/common-parameters/src/main/java/org/onap/policy/common/parameters/FieldValidator.java @@ -0,0 +1,216 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP + * ================================================================================ + * Copyright (C) 2020 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.common.parameters; + +import java.lang.annotation.Annotation; +import java.lang.reflect.Field; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.lang.reflect.Modifier; +import lombok.AccessLevel; +import lombok.Getter; +import lombok.Setter; +import org.apache.commons.lang3.StringUtils; +import org.onap.policy.common.parameters.annotations.NotNull; + +/** + * Validator of the contents of a field, supporting the parameter annotations. + */ +public class FieldValidator extends ValueValidator { + + /** + * {@code True} if there is a field-level annotation, {@code false} otherwise. + */ + @Getter + @Setter(AccessLevel.PROTECTED) + private boolean fieldAnnotated = false; + + /** + * Class containing the field of interest. + */ + private final Class<?> clazz; + + /** + * Field of interest. + */ + private final Field field; + + /** + * Method to retrieve the field's value. + */ + private Method accessor; + + + /** + * Constructs the object. + * + * @param validator provider of validation methods + * @param clazz class containing the field + * @param field field whose value is to be validated + */ + public FieldValidator(BeanValidator validator, Class<?> clazz, Field field) { + this.clazz = clazz; + this.field = field; + + String fieldName = field.getName(); + if (fieldName.contains("$")) { + return; + } + + validator.addValidators(this); + + if (checkers.isEmpty()) { + // has no annotations - nothing to check + return; + } + + // verify the field type is of interest + int mod = field.getModifiers(); + if (Modifier.isStatic(mod)) { + classOnly(clazz.getName() + "." + fieldName + " is annotated but the field is static"); + checkers.clear(); + return; + } + + // get the field's "getter" method + accessor = getAccessor(clazz, fieldName); + if (accessor == null) { + classOnly(clazz.getName() + "." + fieldName + " is annotated but has no \"get\" method"); + checkers.clear(); + return; + } + + // determine if null is allowed + if (field.getAnnotation(NotNull.class) != null || clazz.getAnnotation(NotNull.class) != null) { + setNullAllowed(false); + } + } + + /** + * Performs validation of a single field. + * + * @param result validation results are added here + * @param object object whose field is to be validated + */ + public void validateField(BeanValidationResult result, Object object) { + if (isEmpty()) { + // has no annotations - nothing to check + return; + } + + // get the value + Object value = getValue(object, accessor); + + validateValue(result, field.getName(), value); + } + + /** + * Gets the value from the object using the accessor function. + * + * @param object object whose value is to be retrieved + * @param accessor "getter" method + * @return the object's value + */ + private Object getValue(Object object, Method accessor) { + try { + return accessor.invoke(object); + + } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { + throw new IllegalArgumentException(clazz.getName() + "." + field.getName() + " accessor threw an exception", + e); + } + } + + /** + * Throws an exception if there are field-level annotations. + * + * @param exceptionMessage exception message + */ + private void classOnly(String exceptionMessage) { + if (isFieldAnnotated()) { + throw new IllegalArgumentException(exceptionMessage); + } + } + + /** + * Gets an annotation from the field or the class. + * + * @param annotClass annotation class of interest + * @return the annotation, or {@code null} if neither the field nor the class has the + * desired annotation + */ + public <T extends Annotation> T getAnnotation(Class<T> annotClass) { + + // field annotation takes precedence over class annotation + T annot = field.getAnnotation(annotClass); + if (annot != null) { + setFieldAnnotated(true); + return annot; + } + + return clazz.getAnnotation(annotClass); + } + + /** + * Gets an accessor method for the given field. + * + * @param clazz class whose methods are to be searched + * @param fieldName field whose "getter" is to be identified + * @return the field's "getter" method, or {@code null} if it is not found + */ + private Method getAccessor(Class<?> clazz, String fieldName) { + String capname = StringUtils.capitalize(fieldName); + Method accessor = getMethod(clazz, "get" + capname); + if (accessor != null) { + return accessor; + } + + return getMethod(clazz, "is" + capname); + } + + /** + * Gets the "getter" method having the specified name. + * + * @param clazz class whose methods are to be searched + * @param methodName name of the method of interest + * @return the method, or {@code null} if it is not found + */ + private Method getMethod(Class<?> clazz, String methodName) { + for (Method method : clazz.getMethods()) { + if (methodName.equals(method.getName()) && validMethod(method)) { + return method; + } + } + + return null; + } + + /** + * Determines if a method is a valid "getter". + * + * @param method method to be checked + * @return {@code true} if the method is a valid "getter", {@code false} otherwise + */ + private boolean validMethod(Method method) { + int mod = method.getModifiers(); + return !(Modifier.isStatic(mod) || method.getReturnType() == void.class || method.getParameterCount() != 0); + } +} diff --git a/common-parameters/src/main/java/org/onap/policy/common/parameters/ItemValidator.java b/common-parameters/src/main/java/org/onap/policy/common/parameters/ItemValidator.java new file mode 100644 index 00000000..d0c027c1 --- /dev/null +++ b/common-parameters/src/main/java/org/onap/policy/common/parameters/ItemValidator.java @@ -0,0 +1,108 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP + * ================================================================================ + * Copyright (C) 2020 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.common.parameters; + +import java.lang.annotation.Annotation; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; + +/** + * Validator of an "item", which is typically found in a collection, or the key or value + * components of an entry in a Map. + */ +public class ItemValidator extends ValueValidator { + private final Annotation annotationContainer; + + /** + * Constructs the object. + * + * @param validator provider of validation methods + * @param annotationContainer an annotation containing validation annotations to be + * applied to the item + */ + public ItemValidator(BeanValidator validator, Annotation annotationContainer) { + this(validator, annotationContainer, true); + } + + /** + * Constructs the object. + * + * @param validator provider of validation methods + * @param annotationContainer an annotation containing validation annotations to be + * applied to the item + * @param addValidators {@code true} if to add validators + */ + public ItemValidator(BeanValidator validator, Annotation annotationContainer, boolean addValidators) { + this.annotationContainer = annotationContainer; + + if (addValidators) { + validator.addValidators(this); + } + } + + /** + * Gets an annotation from the field or the class. + * + * @param annotClass annotation class of interest + * @return the annotation, or {@code null} if the {@link #annotationContainer} does + * not contain the desired annotation + */ + public <T extends Annotation> T getAnnotation(Class<T> annotClass) { + try { + for (Method meth : annotationContainer.getClass().getDeclaredMethods()) { + T annot = getAnnotation2(annotClass, meth); + if (annot != null) { + return annot; + } + } + } catch (RuntimeException | IllegalAccessException | InvocationTargetException e) { + throw new IllegalArgumentException("cannot determine " + annotClass.getName(), e); + } + + return null; + } + + private <T extends Annotation> T getAnnotation2(Class<T> annotClass, Method method) + throws IllegalAccessException, IllegalArgumentException, InvocationTargetException { + + Class<?> ret = method.getReturnType(); + if (!ret.isArray()) { + return null; + } + + Class<?> comp = ret.getComponentType(); + if (comp != annotClass) { + return null; + } + + // get the array for this type of annotation + @SuppressWarnings("unchecked") + T[] arrobj = (T[]) method.invoke(annotationContainer); + + if (arrobj.length == 0) { + return null; + } + + // TODO log if there's more than one item + + return arrobj[0]; + } +} diff --git a/common-parameters/src/main/java/org/onap/policy/common/parameters/ValueValidator.java b/common-parameters/src/main/java/org/onap/policy/common/parameters/ValueValidator.java new file mode 100644 index 00000000..9095bfd0 --- /dev/null +++ b/common-parameters/src/main/java/org/onap/policy/common/parameters/ValueValidator.java @@ -0,0 +1,158 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP + * ================================================================================ + * Copyright (C) 2020 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.common.parameters; + +import java.lang.annotation.Annotation; +import java.util.ArrayList; +import java.util.List; +import lombok.AccessLevel; +import lombok.Getter; +import lombok.Setter; +import org.onap.policy.common.parameters.annotations.NotNull; + +/** + * Validator of a value. + * <p/> + * Note: this currently does not support Min/Max validation of "short" or "byte"; these + * annotations are simply ignored for these types. + */ +public class ValueValidator { + + /** + * {@code True} if there is a field-level annotation, {@code false} otherwise. + */ + @Setter(AccessLevel.PROTECTED) + private boolean fieldIsAnnotated = false; + + /** + * {@code True} if the value is allowed to be {@code null}, {@code false} otherwise. + * Subclasses are expected to set this, typically based on the validation annotations + * associated with the value. + */ + @Getter + @Setter(AccessLevel.PROTECTED) + private boolean nullAllowed = true; + + /** + * Predicates to invoke to validate an object. + * <p/> + * Note: each predicate is expected to return {@code true} if the next check is + * allowed to proceed, {@code false} otherwise. In addition, if {@link #nullAllowed} + * is {@code true}, then the predicates must be prepared to deal with a {@code null} + * Object as their input parameter. + */ + protected List<Checker> checkers = new ArrayList<>(10); + + + /** + * Constructs the object. + */ + public ValueValidator() { + // do nothing + } + + /** + * Determines if the validator has anything to check. + * + * @return {@code true} if the validator is empty (i.e., has nothing to check) + */ + public boolean isEmpty() { + return checkers.isEmpty(); + } + + /** + * Performs validation of a single field. + * + * @param result validation results are added here + * @param fieldName field whose value is being verified + * @param value value to be validated + */ + protected void validateValue(BeanValidationResult result, String fieldName, Object value) { + + if (value == null && isNullAllowed()) { + // value is null and null is allowed - just return + return; + } + + for (Checker checker : checkers) { + if (!checker.test(result, fieldName, value)) { + // invalid - don't bother with additional checks + return; + } + } + } + + /** + * Looks for an annotation at the class or field level. If an annotation is found at + * either the field or class level, then it adds a verifier to + * {@link ValueValidator#checkers}. + * + * @param annotClass class of annotation to find + * @param checker function to validate the value + */ + public <T extends Annotation> void addAnnotation(Class<T> annotClass, Checker checker) { + T annot = getAnnotation(annotClass); + if (annot != null) { + checkers.add(checker); + + if (annotClass == NotNull.class) { + setNullAllowed(false); + } + } + } + + /** + * Looks for an annotation at the class or field level. If an annotation is found at + * either the field or class level, then it adds a verifier to + * {@link ValueValidator#checkers}. + * + * @param annotClass class of annotation to find + * @param checker function to validate the value + */ + public <T extends Annotation> void addAnnotation(Class<T> annotClass, CheckerWithAnnot<T> checker) { + T annot = getAnnotation(annotClass); + if (annot != null) { + checkers.add((result, fieldName, value) -> checker.test(result, fieldName, annot, value)); + } + } + + /** + * Gets an annotation from the field or the class. The default method simply returns + * {@code null}. + * + * @param annotClass annotation class of interest + * @return the annotation, or {@code null} if neither the field nor the class has the + * desired annotation + */ + public <T extends Annotation> T getAnnotation(Class<T> annotClass) { + return null; + } + + // functions to validate a value extracted from a field + + public static interface Checker { + boolean test(BeanValidationResult result, String fieldName, Object value); + } + + public static interface CheckerWithAnnot<T extends Annotation> { + boolean test(BeanValidationResult result, String fieldName, T annotation, Object value); + } +} diff --git a/common-parameters/src/main/java/org/onap/policy/common/parameters/annotations/Entries.java b/common-parameters/src/main/java/org/onap/policy/common/parameters/annotations/Entries.java new file mode 100644 index 00000000..89c9ce26 --- /dev/null +++ b/common-parameters/src/main/java/org/onap/policy/common/parameters/annotations/Entries.java @@ -0,0 +1,45 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP + * ================================================================================ + * Copyright (C) 2020 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.common.parameters.annotations; + +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.RetentionPolicy.RUNTIME; + +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +/** + * Validations on entries within a Map. + */ +@Retention(RUNTIME) +@Target(FIELD) +public @interface Entries { + + /** + * Validations to perform on each entry's key. + */ + Items key(); + + /** + * Validations to perform on each entry's value. + */ + Items value(); +} diff --git a/common-parameters/src/main/java/org/onap/policy/common/parameters/annotations/Items.java b/common-parameters/src/main/java/org/onap/policy/common/parameters/annotations/Items.java new file mode 100644 index 00000000..d022d95e --- /dev/null +++ b/common-parameters/src/main/java/org/onap/policy/common/parameters/annotations/Items.java @@ -0,0 +1,66 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP + * ================================================================================ + * Copyright (C) 2020 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.common.parameters.annotations; + +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.RetentionPolicy.RUNTIME; + +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +/** + * Validations on individual items, typically within a collection. + */ +@Retention(RUNTIME) +@Target(FIELD) +public @interface Items { + + /** + * Validates the item is not {@code null}. + */ + NotNull[] notNull() default {}; + + /** + * Validates the item is not blank. + */ + NotBlank[] notBlank() default {}; + + /** + * Validates the item matches a regular expression. + */ + Pattern[] pattern() default {}; + + /** + * Validates the item is not greater than a certain value. + */ + Max[] max() default {}; + + /** + * Validates the item is not less than a certain value. + */ + Min[] min() default {}; + + /** + * Validates the item is valid, using a {@link BeanValidator}. + */ + Valid[] valid() default {}; + +} diff --git a/common-parameters/src/main/java/org/onap/policy/common/parameters/annotations/Pattern.java b/common-parameters/src/main/java/org/onap/policy/common/parameters/annotations/Pattern.java new file mode 100644 index 00000000..a30d814c --- /dev/null +++ b/common-parameters/src/main/java/org/onap/policy/common/parameters/annotations/Pattern.java @@ -0,0 +1,37 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP + * ================================================================================ + * Copyright (C) 2020 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.common.parameters.annotations; + +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.RetentionPolicy.RUNTIME; + +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +@Retention(RUNTIME) +@Target(FIELD) +public @interface Pattern { + + /** + * Regular expression to be matched. + */ + String regexp(); +} diff --git a/common-parameters/src/main/java/org/onap/policy/common/parameters/annotations/Valid.java b/common-parameters/src/main/java/org/onap/policy/common/parameters/annotations/Valid.java new file mode 100644 index 00000000..a3a1d59f --- /dev/null +++ b/common-parameters/src/main/java/org/onap/policy/common/parameters/annotations/Valid.java @@ -0,0 +1,34 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP + * ================================================================================ + * Copyright (C) 2020 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.common.parameters.annotations; + +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.ElementType.TYPE; +import static java.lang.annotation.RetentionPolicy.RUNTIME; + +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +@Retention(RUNTIME) +@Target({TYPE, FIELD}) +public @interface Valid { + +} |