) ) { validateTypeArgumentConstraints( context, buildNewLocalExecutionContext( valueContext, value ), value, typeArgumentsConstraint ); validateInContext( context, buildNewLocalExecutionContext( valueContext, value ), validationOrder ); if ( shouldFailFast( context ) ) { return;
@Override public final <T> Set<ConstraintViolation<T>> validateProperty(T object, String propertyName, Class<?>... groups) { Contracts.assertNotNull( object, MESSAGES.validatedObjectMustNotBeNull() ); sanityCheckPropertyPath( propertyName ); sanityCheckGroups( groups ); ValidationContext<T> validationContext = getValidationContextBuilder().forValidateProperty( object ); if ( !validationContext.getRootBeanMetaData().hasConstraints() ) { return Collections.emptySet(); } PathImpl propertyPath = PathImpl.createPathFromString( propertyName ); ValueContext<?, Object> valueContext = getValueContextForPropertyValidation( validationContext, propertyPath ); if ( valueContext.getCurrentBean() == null ) { throw LOG.getUnableToReachPropertyToValidateException( validationContext.getRootBean(), propertyPath ); } ValidationOrder validationOrder = determineGroupValidationOrder( groups ); return validateInContext( validationContext, valueContext, validationOrder ); }
private <T> void validateReturnValueForSingleGroup(ValidationContext<T> validationContext, ExecutableMetaData executableMetaData, T bean, Object value, Class<?> oneGroup) { // validate constraints at return value itself ValueContext<?, Object> valueContext = getExecutableValueContext( executableMetaData.getKind() == ElementKind.CONSTRUCTOR ? value : bean, executableMetaData, executableMetaData.getReturnValueMetaData(), oneGroup ); ReturnValueMetaData returnValueMetaData = executableMetaData.getReturnValueMetaData(); validateMetaConstraints( validationContext, valueContext, value, returnValueMetaData ); }
private boolean needToCallTraversableResolver(PathImpl path, ElementType type) { // as the TraversableResolver interface is designed right now it does not make sense to call it when // there is no traversable object hosting the property to be accessed. For this reason we don't call the resolver // for class level constraints (ElementType.TYPE) or top level method parameters or return values. // see also BV expert group discussion - http://lists.jboss.org/pipermail/beanvalidation-dev/2013-January/000722.html return isClassLevelConstraint( type ) || isCrossParameterValidation( path ) || isParameterValidation( path ) || isReturnValueValidation( path ); }
private <T> Set<ConstraintViolation<T>> validateReturnValue(T object, Executable executable, Object returnValue, Class<?>... groups) { sanityCheckGroups( groups ); ValidationContext<T> validationContext = getValidationContextBuilder().forValidateReturnValue( object, executable, returnValue ); if ( !validationContext.getRootBeanMetaData().hasConstraints() ) { return Collections.emptySet(); } ValidationOrder validationOrder = determineGroupValidationOrder( groups ); validateReturnValueInContext( validationContext, object, returnValue, validationOrder ); return validationContext.getFailingConstraints(); }
private <T> Set<ConstraintViolation<T>> validateReturnValue(T object, ExecutableElement executable, Object returnValue, Class<?>... groups) { ValidationOrder validationOrder = determineGroupValidationOrder( groups ); ValidationContext<T> context = getValidationContext().forValidateReturnValue( object, executable, returnValue ); if ( !beanMetaDataManager.isConstrained( context.getRootBeanClass() ) ) { return Collections.emptySet(); } validateReturnValueInContext( context, object, returnValue, validationOrder ); return context.getFailingConstraints(); }
@Override public final <T> Set<ConstraintViolation<T>> validateValue(Class<T> beanType, String propertyName, Object value, Class<?>... groups) { Contracts.assertNotNull( beanType, MESSAGES.beanTypeCannotBeNull() ); sanityCheckPropertyPath( propertyName ); sanityCheckGroups( groups ); ValidationContext<T> validationContext = getValidationContextBuilder().forValidateValue( beanType ); if ( !validationContext.getRootBeanMetaData().hasConstraints() ) { return Collections.emptySet(); } ValidationOrder validationOrder = determineGroupValidationOrder( groups ); return validateValueInContext( validationContext, value, PathImpl.createPathFromString( propertyName ), validationOrder ); }
@Override public final <T> Set<ConstraintViolation<T>> validateValue(Class<T> beanType, String propertyName, Object value, Class<?>... groups) { Contracts.assertNotNull( beanType, MESSAGES.beanTypeCannotBeNull() ); if ( !beanMetaDataManager.isConstrained( beanType ) ) { return Collections.emptySet(); } sanityCheckPropertyPath( propertyName ); ValidationOrder validationOrder = determineGroupValidationOrder( groups ); ValidationContext<T> context = getValidationContext().forValidateValue( beanType ); return validateValueInContext( context, value, PathImpl.createPathFromString( propertyName ), validationOrder ); }
private <T> Set<ConstraintViolation<T>> validateParameters(T object, Executable executable, Object[] parameterValues, Class<?>... groups) { sanityCheckGroups( groups ); ValidationContext<T> validationContext = getValidationContextBuilder().forValidateParameters( validatorScopedContext.getParameterNameProvider(), object, executable, parameterValues ); if ( !validationContext.getRootBeanMetaData().hasConstraints() ) { return Collections.emptySet(); } ValidationOrder validationOrder = determineGroupValidationOrder( groups ); validateParametersInContext( validationContext, parameterValues, validationOrder ); return validationContext.getFailingConstraints(); }
if ( isCascadeRequired( validationContext, valueContext.getCurrentBean(), ) ) { Object value = getBeanPropertyValue( validationContext, valueContext.getCurrentBean(), cascadable ); validateCascadedConstraint( validationContext, valueContext, Collections.<MetaConstraint<?>>emptySet() ); if ( shouldFailFast( validationContext ) ) { return; Iterator<?> elementsIter = createIteratorForCascadedValue( valueContext, type, value ); boolean isIndexable = ReflectionHelper.isIndexable( type ); validateCascadedConstraint( validationContext, valueContext, cascadable.getTypeArgumentsConstraints() ); if ( shouldFailFast( validationContext ) ) { return;
@Override public final <T> Set<ConstraintViolation<T>> validateProperty(T object, String propertyName, Class<?>... groups) { Contracts.assertNotNull( object, MESSAGES.validatedObjectMustNotBeNull() ); sanityCheckPropertyPath( propertyName ); ValidationOrder validationOrder = determineGroupValidationOrder( groups ); ValidationContext<T> context = getValidationContext().forValidateProperty( object ); if ( !beanMetaDataManager.isConstrained( context.getRootBeanClass() ) ) { return Collections.emptySet(); } return validatePropertyInContext( context, PathImpl.createPathFromString( propertyName ), validationOrder ); }
private void validateCascadedAnnotatedObjectForCurrentGroup(Object value, ValidationContext<?> validationContext, ValueContext<?, Object> valueContext, CascadingMetaData cascadingMetaData) { if ( validationContext.isBeanAlreadyValidated( value, valueContext.getCurrentGroup(), valueContext.getPropertyPath() ) || shouldFailFast( validationContext ) ) { return; } Class<?> originalGroup = valueContext.getCurrentGroup(); Class<?> currentGroup = cascadingMetaData.convertGroup( originalGroup ); // expand the group only if was created by group conversion; // otherwise we're looping through the right validation order // already and need only to pass the current element ValidationOrder validationOrder = validationOrderGenerator.getValidationOrder( currentGroup, currentGroup != originalGroup ); ValueContext<?, Object> cascadedValueContext = buildNewLocalExecutionContext( valueContext, value ); validateInContext( validationContext, cascadedValueContext, validationOrder ); }
@Override public final <T> Set<ConstraintViolation<T>> validate(T object, Class<?>... groups) { Contracts.assertNotNull( object, MESSAGES.validatedObjectMustNotBeNull() ); sanityCheckGroups( groups ); ValidationContext<T> validationContext = getValidationContextBuilder().forValidate( object ); if ( !validationContext.getRootBeanMetaData().hasConstraints() ) { return Collections.emptySet(); } ValidationOrder validationOrder = determineGroupValidationOrder( groups ); ValueContext<?, Object> valueContext = ValueContext.getLocalExecutionContext( validatorScopedContext.getParameterNameProvider(), object, validationContext.getRootBeanMetaData(), PathImpl.createRootPath() ); return validateInContext( validationContext, valueContext, validationOrder ); }
private <T> void validateReturnValueForSingleGroup(ValidationContext<T> validationContext, ExecutableMetaData executableMetaData, T bean, Object value, Class<?> oneGroup) { // validate constraints at return value itself ValueContext<?, Object> valueContext = getExecutableValueContext( executableMetaData.getKind() == ElementKind.CONSTRUCTOR ? value : bean, executableMetaData, oneGroup ); valueContext.setCurrentValidatedValue( value ); ReturnValueMetaData returnValueMetaData = executableMetaData.getReturnValueMetaData(); valueContext.appendNode( returnValueMetaData ); valueContext.setUnwrapMode( returnValueMetaData.unwrapMode() ); validateConstraintsForGroup( validationContext, valueContext, returnValueMetaData ); if ( shouldFailFast( validationContext ) ) { return; } if ( !returnValueMetaData.isCascading() ) { validateConstraintsForGroup( validationContext, valueContext, returnValueMetaData.getTypeArgumentsConstraints() ); if ( shouldFailFast( validationContext ) ) { return; } } }
private <T> Set<ConstraintViolation<T>> validateParameters(T object, ExecutableElement executable, Object[] parameterValues, Class<?>... groups) { //this might be the case for parameterless methods if ( parameterValues == null ) { return Collections.emptySet(); } ValidationOrder validationOrder = determineGroupValidationOrder( groups ); ValidationContext<T> context = getValidationContext().forValidateParameters( parameterNameProvider, object, executable, parameterValues ); if ( !beanMetaDataManager.isConstrained( context.getRootBeanClass() ) ) { return Collections.emptySet(); } validateParametersInContext( context, parameterValues, validationOrder ); return context.getFailingConstraints(); }
@Override public final <T> Set<ConstraintViolation<T>> validate(T object, Class<?>... groups) { Contracts.assertNotNull( object, MESSAGES.validatedObjectMustNotBeNull() ); if ( !beanMetaDataManager.isConstrained( object.getClass() ) ) { return Collections.emptySet(); } ValidationOrder validationOrder = determineGroupValidationOrder( groups ); ValidationContext<T> validationContext = getValidationContext().forValidate( object ); ValueContext<?, Object> valueContext = ValueContext.getLocalExecutionContext( object, beanMetaDataManager.getBeanMetaData( object.getClass() ), PathImpl.createRootPath() ); return validateInContext( validationContext, valueContext, validationOrder ); }
private <T> void validateParametersForSingleGroup(ValidationContext<T> validationContext, Object[] parameterValues, ExecutableMetaData executableMetaData, Class<?> currentValidatedGroup) { if ( !executableMetaData.getCrossParameterConstraints().isEmpty() ) { ValueContext<T, Object> valueContext = getExecutableValueContext( validationContext.getRootBean(), executableMetaData, executableMetaData.getValidatableParametersMetaData(), currentValidatedGroup ); validateMetaConstraints( validationContext, valueContext, parameterValues, executableMetaData.getCrossParameterConstraints() ); if ( shouldFailFast( validationContext ) ) { return; ValueContext<T, Object> valueContext = getExecutableValueContext( validationContext.getRootBean(), executableMetaData, executableMetaData.getValidatableParametersMetaData(), currentValidatedGroup ); validateMetaConstraints( validationContext, valueContext, parameterValues, parameterMetaData ); if ( shouldFailFast( validationContext ) ) { return;
if ( isCascadeRequired( validationContext, valueContext.getCurrentBean(), valueContext.getPropertyPath(), elementType ) ) { Object value = getCascadableValue( validationContext, valueContext.getCurrentBean(), cascadable ); CascadingMetaData cascadingMetaData = cascadable.getCascadingMetaData(); validateCascadedAnnotatedObjectForCurrentGroup( value, validationContext, valueContext, effectiveCascadingMetaData ); validateCascadedContainerElementsForCurrentGroup( value, validationContext, valueContext, containerCascadingMetaData.getContainerElementTypesCascadingMetaData() );
private boolean isCascadeRequired(ValidationContext<?> validationContext, Object traversableObject, PathImpl path, ElementType type) { if ( needToCallTraversableResolver( path, type ) ) { return true; } boolean isReachable = isReachable( validationContext, traversableObject, path, type ); if ( !isReachable ) { return false; } Path pathToObject = path.getPathWithoutLeafNode(); try { return validationContext.getTraversableResolver().isCascadable( traversableObject, path.getLeafNode(), validationContext.getRootBeanClass(), pathToObject, type ); } catch (RuntimeException e) { throw LOG.getErrorDuringCallOfTraversableResolverIsCascadableException( e ); } }
private boolean isValidationRequired(ValidationContext<?> validationContext, ValueContext<?, ?> valueContext, MetaConstraint<?> metaConstraint) { // validateProperty()/validateValue() call, but this constraint is for another property if ( validationContext.getValidatedProperty() != null && !Objects.equals( validationContext.getValidatedProperty(), getPropertyName( metaConstraint.getLocation() ) ) ) { return false; } if ( validationContext.hasMetaConstraintBeenProcessed( valueContext.getCurrentBean(), valueContext.getPropertyPath(), metaConstraint ) ) { return false; } if ( !metaConstraint.getGroupList().contains( valueContext.getCurrentGroup() ) ) { return false; } return isReachable( validationContext, valueContext.getCurrentBean(), valueContext.getPropertyPath(), metaConstraint.getElementType() ); }