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 unit(ChronoUnit unit) {
+		addParameter( "unit", unit );
+		return this;
+	}
+
+	public AgeMinDef inclusive(boolean inclusive) {
+		addParameter( "inclusive", inclusive );
+		return this;
+	}
+}

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

@@ -0,0 +1,99 @@
+/*
+ * 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 an instant, date or time for which at least
+ * the specified amount ({@link AgeMin#value()}) of Years/Days/Months/etc. defined
+ * by {@link AgeMin#unit()} have passed till now.
+ * <p>
+ * Supported types are:
+ * <ul>
+ *     <li>{@code java.util.Calendar}</li>
+ *     <li>{@code java.util.Date}</li>
+ *     <li>{@code java.time.chrono.HijrahDate}</li>
+ *     <li>{@code java.time.chrono.JapaneseDate}</li>
+ *     <li>{@code java.time.LocalDate}</li>
+ *     <li>{@code java.time.chrono.MinguoDate}</li>
+ *     <li>{@code java.time.chrono.ThaiBuddhistDate}</li>
+ *     <li>{@code java.time.Year}</li>
+ *     <li>{@code java.time.YearMonth}</li>
+ * </ul>
+ * <p>
+ * {@code null} elements are considered valid.
+ *
+ *
+ * @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 the age according to unit from a given instant, date or time must be greater or equal to
+	 */
+	int value();
+
+	/**
+	 * Specifies the date period unit ( Years/Days/Months/etc. ) that will be used to compare the given instant,
+	 * date or time with the reference value.
+	 * By default, it is ({@link ChronoUnit#YEARS}).
+	 *
+	 * @return the date period unit
+	 */
+	ChronoUnit unit() default ChronoUnit.YEARS;
+
+	/**
+	 * Specifies whether the specified value is inclusive or exclusive.
+	 * By default, it is inclusive.
+	 *
+	 * @return {@code true} if the date period units from a given instant, date or time must be higher or equal to the specified value,
+	 *         {@code false} if date period units from a given instant, date or time must be higher
+	 */
+	boolean inclusive() default true;
+
+	/**
+	 * 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,97 @@
+/*
+ * 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.lang.invoke.MethodHandles;
+import java.time.Clock;
+import java.time.Duration;
+import java.time.Instant;
+import java.time.LocalDate;
+import java.time.ZoneOffset;
+import java.time.temporal.ChronoUnit;
+
+import javax.validation.ConstraintValidatorContext;
+
+import org.hibernate.validator.constraintvalidation.HibernateConstraintValidator;
+import org.hibernate.validator.constraintvalidation.HibernateConstraintValidatorInitializationContext;
+import org.hibernate.validator.internal.util.logging.Log;
+import org.hibernate.validator.internal.util.logging.LoggerFactory;
+
+/**
+ * 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> {
+
+	private static final Log LOG = LoggerFactory.make( MethodHandles.lookup() );
+
+	private Clock referenceClock;
+
+	protected int referenceAge;
+
+	protected boolean inclusive;
+
+	protected ChronoUnit unit;
+
+	public void initialize(
+			int referenceAge,
+			ChronoUnit unit,
+			boolean inclusive,
+			HibernateConstraintValidatorInitializationContext initializationContext) {
+		try {
+			this.referenceClock = Clock.offset(
+					initializationContext.getClockProvider().getClock(),
+					getEffectiveTemporalValidationTolerance( initializationContext.getTemporalValidationTolerance() )
+			);
+		}
+		catch (Exception e) {
+			throw LOG.getUnableToGetCurrentTimeFromClockProvider( e );
+		}
+		this.referenceAge = referenceAge;
+		this.unit = unit;
+		this.inclusive = inclusive;
+	}
+
+	@Override
+	public boolean isValid(T value, ConstraintValidatorContext context) {
+		// null values are valid
+		if ( value == null ) {
+			return true;
+		}
+		// As Instant does not support plus operation on ChronoUnits greater than DAYS we need to convert it to LocalDate
+		// first, which supports such operations.
+
+		long result = getInstant( value ).atZone( ZoneOffset.ofHours( 0 ) )
+				.toLocalDate()
+				.plus( referenceAge, unit )
+				.compareTo(
+						LocalDate.now( referenceClock ) );
+
+		return isValid( result );
+	}
+
+	/**
+	 * Returns the temporal validation tolerance to apply.
+	 */
+	protected abstract Duration getEffectiveTemporalValidationTolerance(Duration absoluteTemporalValidationTolerance);
+
+	/**
+	 * Returns the {@link Instant} measured from Epoch.
+	 */
+	protected abstract Instant getInstant(T value);
+
+	/**
+	 * Returns whether the result of the comparison between the validated value and the reference age 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,88 @@
+/*
+ * 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.lang.invoke.MethodHandles;
+import java.time.Clock;
+import java.time.Duration;
+import java.time.temporal.ChronoUnit;
+import java.time.temporal.TemporalAccessor;
+
+import javax.validation.ClockProvider;
+import javax.validation.ConstraintValidatorContext;
+
+import org.hibernate.validator.constraintvalidation.HibernateConstraintValidator;
+import org.hibernate.validator.constraintvalidation.HibernateConstraintValidatorInitializationContext;
+import org.hibernate.validator.internal.util.logging.Log;
+import org.hibernate.validator.internal.util.logging.LoggerFactory;
+
+/**
+ * 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> {
+
+	private static final Log LOG = LoggerFactory.make( MethodHandles.lookup() );
+
+	private Clock referenceClock;
+
+	protected int referenceAge;
+
+	protected boolean inclusive;
+
+	protected ChronoUnit unit;
+
+	public void initialize(int referenceAge, ChronoUnit unit, boolean inclusive, HibernateConstraintValidatorInitializationContext initializationContext) {
+		try {
+			this.referenceClock = Clock.offset(
+					initializationContext.getClockProvider().getClock(),
+					getEffectiveTemporalValidationTolerance( initializationContext.getTemporalValidationTolerance() )
+			);
+		}
+		catch (Exception e) {
+			throw LOG.getUnableToGetCurrentTimeFromClockProvider( e );
+		}
+		this.referenceAge = referenceAge;
+		this.unit = unit;
+		this.inclusive = inclusive;
+	}
+
+	@Override
+	public boolean isValid(T value, ConstraintValidatorContext context) {
+		// null values are valid
+		if ( value == null ) {
+			return true;
+		}
+
+		int result = value.compareTo( getReferenceValue( referenceClock, referenceAge, unit ) );
+
+		return isValid( result );
+	}
+
+	/**
+	 * Returns the temporal validation tolerance to apply.
+	 */
+	protected abstract Duration getEffectiveTemporalValidationTolerance(Duration absoluteTemporalValidationTolerance);
+
+	/**
+	 * Returns an object of the validated type corresponding to the time reference as provided by the
+	 * {@link ClockProvider} increased or decreased with the specified referenceAge of Years/Days/Months/etc.
+	 * defined by {@link ChronoUnit}.
+	 */
+	protected abstract T getReferenceValue(Clock reference, int referenceAge, ChronoUnit unit );
+
+	/**
+	 * 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,42 @@
+/*
+ * 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.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;
+
+
+/**
+ * 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>  {
+
+	@Override
+	public void initialize(ConstraintDescriptor<AgeMin> constraintDescriptor, HibernateConstraintValidatorInitializationContext initializationContext) {
+		super.initialize( constraintDescriptor.getAnnotation().value(), constraintDescriptor.getAnnotation().unit(),
+						  constraintDescriptor.getAnnotation().inclusive(), initializationContext );
+	}
+
+	@Override
+	protected Duration getEffectiveTemporalValidationTolerance(Duration absoluteTemporalValidationTolerance) {
+		return absoluteTemporalValidationTolerance;
+	}
+
+	@Override
+	protected boolean isValid(long result) {
+		return this.inclusive ? result <= 0 : result < 0;
+	}
+}