HV-1552 Adding new MinAge Constraint

engine/src/main/java/org/hibernate/validator/cfg/defs/AgeMinDef.java

@@ -0,0 +1,38 @@
+/*
+ * Hibernate Validator, declare and validate application constraints
+ *
+ * License: Apache License, Version 2.0
+ * See the license.txt file in the root directory or <http://www.apache.org/licenses/LICENSE-2.0>.
+ */
+package org.hibernate.validator.cfg.defs;
+
+import org.hibernate.validator.cfg.ConstraintDef;
+import org.hibernate.validator.constraints.AgeMin;
+
+import java.time.temporal.ChronoUnit;
+
+/**
+ * @author Hillmer Chona
+ * @since 6.0.8
+ */
+public class AgeMinDef extends ConstraintDef<AgeMinDef, AgeMin> {
+
+	public AgeMinDef() {
+		super( AgeMin.class );
+	}
+
+	public AgeMinDef value(int value) {
+		addParameter( "value", value );
+		return this;
+	}
+
+	public AgeMinDef inclusive(boolean inclusive) {
+		addParameter( "inclusive", inclusive );
+		return this;
+	}
+
+	public AgeMinDef unit(ChronoUnit unit) {
+		addParameter( "unit", unit );
+		return this;
+	}
+}

engine/src/main/java/org/hibernate/validator/constraints/AgeMin.java

@@ -0,0 +1,90 @@
+/*
+ * Hibernate Validator, declare and validate application constraints
+ *
+ * License: Apache License, Version 2.0
+ * See the license.txt file in the root directory or <http://www.apache.org/licenses/LICENSE-2.0>.
+ */
+package org.hibernate.validator.constraints;
+
+import javax.validation.Constraint;
+import javax.validation.Payload;
+import java.lang.annotation.Documented;
+import java.lang.annotation.Repeatable;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+import java.time.temporal.ChronoUnit;
+
+
+import static java.lang.annotation.ElementType.ANNOTATION_TYPE;
+import static java.lang.annotation.ElementType.CONSTRUCTOR;
+import static java.lang.annotation.ElementType.FIELD;
+import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.ElementType.PARAMETER;
+import static java.lang.annotation.ElementType.TYPE_USE;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+/**
+ * The annotated element must be a date where the number of Years, Days, Months, etc. according
+ * to an unit {@code java.time.temporal.ChronoUnit} go by to today must be
+ * greater or equal to the specified value if inclusive is true
+ * or is greater when inclusive is false.
+ * <p>
+ * <p>
+ * The supported type is {@code LocalDate}. {@code null} is considered valid.
+ * The supported type is {@code Calendar}. {@code null} is considered valid.
+ * <p>
+ *
+ * @author Hillmer Chona
+ * @since 6.0.8
+ */
+@Target({METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE})
+@Retention(RUNTIME)
+@Repeatable(AgeMin.List.class)
+@Documented
+@Constraint(validatedBy = {})
+public @interface AgeMin {
+
+	String message() default "{org.hibernate.validator.constraints.AgeMin.message}";
+
+	Class<?>[] groups() default {};
+
+	Class<? extends Payload>[] payload() default {};
+
+	/**
+	 * @return value the referenceAge according to unit from a given date must be greater or equal to
+	 */
+	int value();
+
+	/**
+	 * Specifies whether the specified value is inclusive or exclusive.
+	 * By default, it is inclusive.
+	 *
+	 * @return {@code true} if the number of years from a given date must be higher or equal to the specified value,
+	 *         {@code false} if the number of years from a given date must be higher
+	 */
+	boolean inclusive() default true;
+
+
+	/**
+	 * Specifies the date period unit ( years, months, days, etc.) that will be used to compare the given date
+	 * with the reference value.
+	 * By default, it is YEARS.
+	 *
+	 * @return unit the date period unit
+	 */
+	ChronoUnit unit() default ChronoUnit.YEARS;
+
+	/**
+	 * Defines several {@link AgeMin} annotations on the same element.
+	 *
+	 * @see AgeMin
+	 */
+	@Target({METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE})
+	@Retention(RUNTIME)
+	@Documented
+	@interface List {
+		AgeMin[] value();
+	}
+
+
+}

engine/src/main/java/org/hibernate/validator/internal/constraintvalidators/hv/age/AbstractAgeInstantBasedValidator.java

@@ -0,0 +1,63 @@
+/*
+ * Hibernate Validator, declare and validate application constraints
+ *
+ * License: Apache License, Version 2.0
+ * See the license.txt file in the root directory or <http://www.apache.org/licenses/LICENSE-2.0>.
+ */
+package org.hibernate.validator.internal.constraintvalidators.hv.age;
+
+import java.lang.annotation.Annotation;
+import java.time.Clock;
+import java.time.Duration;
+import java.time.Instant;
+import java.time.temporal.ChronoUnit;
+
+import javax.validation.ConstraintValidatorContext;
+
+import org.hibernate.validator.constraintvalidation.HibernateConstraintValidator;
+
+/**
+ * Base class for all age validators that use an {@link Instant} to be compared to the age reference.
+ *
+ * @author Hillmer Chona
+ * @since 6.0.8
+ */
+public abstract class AbstractAgeInstantBasedValidator<C extends Annotation, T> implements HibernateConstraintValidator<C, T> {
+
+	protected Clock referenceClock;
+
+	protected int referenceAge;
+
+	protected boolean inclusive;
+
+	protected ChronoUnit unit;
+
+	@Override
+	public boolean isValid(T value, ConstraintValidatorContext context) {
+		// null values are valid
+		if ( value == null ) {
+			return true;
+		}
+
+		long result =  this.getCurrentAge( value ) - this.referenceAge;
+
+		return isValid( result );
+	}
+
+	/**
+	 * Returns the temporal validation tolerance to apply.
+	 */
+	protected abstract Duration getEffectiveTemporalValidationTolerance(Duration absoluteTemporalValidationTolerance);
+
+	/**
+	 * Returns the number of Years, Days, Months, etc. according to an unit {@code java.time.temporal.ChronoUnit}
+	 * from a given {@code java.util.Calendar} to current day
+	 */
+	protected abstract long getCurrentAge(T value);
+
+	/**
+	 * Returns whether the result of the comparison between the validated value and the age reference is considered
+	 * valid.
+	 */
+	protected abstract boolean isValid(long result);
+}

engine/src/main/java/org/hibernate/validator/internal/constraintvalidators/hv/age/AbstractAgeTimeBasedValidator.java

@@ -0,0 +1,64 @@
+/*
+ * Hibernate Validator, declare and validate application constraints
+ *
+ * License: Apache License, Version 2.0
+ * See the license.txt file in the root directory or <http://www.apache.org/licenses/LICENSE-2.0>.
+ */
+package org.hibernate.validator.internal.constraintvalidators.hv.age;
+
+import java.lang.annotation.Annotation;
+import java.time.Clock;
+import java.time.Duration;
+import java.time.temporal.ChronoUnit;
+import java.time.temporal.TemporalAccessor;
+
+import javax.validation.ConstraintValidatorContext;
+
+import org.hibernate.validator.constraintvalidation.HibernateConstraintValidator;
+
+/**
+ * Base class for all age validators that are based on the {@code java.time} package.
+ *
+ * @author Hillmer Chona
+ * @since 6.0.8
+ */
+public abstract class AbstractAgeTimeBasedValidator<C extends Annotation, T extends TemporalAccessor & Comparable<? super T>>
+		implements HibernateConstraintValidator<C, T> {
+
+	protected Clock referenceClock;
+
+	protected int referenceAge;
+
+	protected boolean inclusive;
+
+	protected ChronoUnit unit;
+
+	@Override
+	public boolean isValid(T value, ConstraintValidatorContext context) {
+		// null values are valid
+		if ( value == null ) {
+			return true;
+		}
+
+		long result =  this.getCurrentAge( value ) - this.referenceAge;
+
+		return isValid( result );
+	}
+
+	/**
+	 * Returns the temporal validation tolerance to apply.
+	 */
+	protected abstract Duration getEffectiveTemporalValidationTolerance(Duration absoluteTemporalValidationTolerance);
+
+	/**
+	 * Returns the number of Years, Days, Months, etc. according to an unit {@code java.time.temporal.ChronoUnit}
+	 * from a given {@code java.util.Calendar} to current day
+	 */
+	protected abstract long getCurrentAge(T value);
+
+	/**
+	 * Returns whether the result of the comparison between the validated value and the age reference is considered
+	 * valid.
+	 */
+	protected abstract boolean isValid(long result);
+}

engine/src/main/java/org/hibernate/validator/internal/constraintvalidators/hv/age/min/AbstractAgeMinInstantBasedValidator.java

@@ -0,0 +1,58 @@
+/*
+ * Hibernate Validator, declare and validate application constraints
+ *
+ * License: Apache License, Version 2.0
+ * See the license.txt file in the root directory or <http://www.apache.org/licenses/LICENSE-2.0>.
+ */
+package org.hibernate.validator.internal.constraintvalidators.hv.age.min;
+
+import java.lang.invoke.MethodHandles;
+import java.time.Clock;
+import java.time.Duration;
+import java.time.Instant;
+
+import javax.validation.metadata.ConstraintDescriptor;
+
+import org.hibernate.validator.constraints.AgeMin;
+import org.hibernate.validator.constraintvalidation.HibernateConstraintValidatorInitializationContext;
+import org.hibernate.validator.internal.constraintvalidators.hv.age.AbstractAgeInstantBasedValidator;
+import org.hibernate.validator.internal.util.logging.Log;
+import org.hibernate.validator.internal.util.logging.LoggerFactory;
+
+/**
+ * Base class for all {@code @AgeMin} validators that use an {@link Instant} to be compared to the age reference.
+ *
+ * @author Hillmer Chona
+ * @since 6.0.8
+ */
+public abstract class AbstractAgeMinInstantBasedValidator<T> extends AbstractAgeInstantBasedValidator<AgeMin, T>  {
+
+	private static final Log LOG = LoggerFactory.make( MethodHandles.lookup() );
+
+	@Override
+	public void initialize(ConstraintDescriptor<AgeMin> constraintDescriptor, HibernateConstraintValidatorInitializationContext initializationContext) {
+		try {
+			super.referenceClock  = Clock.offset(
+					initializationContext.getClockProvider().getClock(),
+					getEffectiveTemporalValidationTolerance( initializationContext.getTemporalValidationTolerance() )
+			);
+			super.referenceAge = constraintDescriptor.getAnnotation().value();
+			super.inclusive = constraintDescriptor.getAnnotation().inclusive();
+			super.unit = constraintDescriptor.getAnnotation().unit();
+
+		}
+		catch (Exception e) {
+			throw LOG.getUnableToGetCurrentTimeFromClockProvider( e );
+		}
+	}
+
+	@Override
+	protected Duration getEffectiveTemporalValidationTolerance(Duration absoluteTemporalValidationTolerance) {
+		return absoluteTemporalValidationTolerance;
+	}
+
+	@Override
+	protected boolean isValid(long result) {
+		return super.inclusive ? result >= 0 : result > 0;
+	}
+}

engine/src/main/java/org/hibernate/validator/internal/constraintvalidators/hv/age/min/AbstractAgeMinTimeBasedValidator.java

@@ -0,0 +1,61 @@
+/*
+ * Hibernate Validator, declare and validate application constraints
+ *
+ * License: Apache License, Version 2.0
+ * See the license.txt file in the root directory or <http://www.apache.org/licenses/LICENSE-2.0>.
+ */
+package org.hibernate.validator.internal.constraintvalidators.hv.age.min;
+
+import java.lang.invoke.MethodHandles;
+import java.time.Clock;
+import java.time.Duration;
+import java.time.temporal.Temporal;
+import java.time.temporal.TemporalAccessor;
+
+import javax.validation.metadata.ConstraintDescriptor;
+
+import org.hibernate.validator.constraints.AgeMin;
+import org.hibernate.validator.constraintvalidation.HibernateConstraintValidatorInitializationContext;
+import org.hibernate.validator.internal.constraintvalidators.hv.age.AbstractAgeTimeBasedValidator;
+import org.hibernate.validator.internal.util.logging.Log;
+import org.hibernate.validator.internal.util.logging.LoggerFactory;
+
+/**
+ *
+ * Base class for all {@code @AgeMin} validators that are based on the {@code java.time} package.
+ *
+ * @author Hillmer Chona
+ * @since 6.0.8
+ */
+public abstract class AbstractAgeMinTimeBasedValidator<T extends Temporal & TemporalAccessor & Comparable<? super T>>
+		extends AbstractAgeTimeBasedValidator<AgeMin, T> {
+
+	private static final Log LOG = LoggerFactory.make( MethodHandles.lookup() );
+
+	@Override
+	public void initialize(ConstraintDescriptor<AgeMin> constraintDescriptor, HibernateConstraintValidatorInitializationContext initializationContext) {
+		try {
+			super.referenceClock  = Clock.offset(
+					initializationContext.getClockProvider().getClock(),
+					getEffectiveTemporalValidationTolerance( initializationContext.getTemporalValidationTolerance() )
+			);
+			super.referenceAge = constraintDescriptor.getAnnotation().value();
+			super.inclusive = constraintDescriptor.getAnnotation().inclusive();
+			super.unit = constraintDescriptor.getAnnotation().unit();
+
+		}
+		catch (Exception e) {
+			throw LOG.getUnableToGetCurrentTimeFromClockProvider( e );
+		}
+	}
+
+	@Override
+	protected Duration getEffectiveTemporalValidationTolerance(Duration absoluteTemporalValidationTolerance) {
+		return absoluteTemporalValidationTolerance.negated();
+	}
+
+	@Override
+	protected boolean isValid(long result) {
+		return super.inclusive ? result >= 0 : result > 0;
+	}
+}