String name = node.getName(); if (name != null && node.getKind() == ElementKind.PROPERTY && !name.startsWith("<")) { if (!first) {
private String getStringBasedPath(Path.Node traversableProperty, Path pathToTraversableObject) { StringBuilder path = new StringBuilder( ); for ( Path.Node node : pathToTraversableObject ) { if (node.getName() != null) { path.append( node.getName() ).append( "." ); } } if ( traversableProperty.getName() == null ) { throw new AssertionFailure( "TraversableResolver being passed a traversableProperty with null name. pathToTraversableObject: " + path.toString() ); } path.append( traversableProperty.getName() ); return path.toString(); }
String name = node.getName(); if (name != null && node.getKind() == ElementKind.PROPERTY && !name.startsWith("<")) { if (!first) {
static Node findLastNonEmptyPathNode(final Path path) { Node found = null; final List<Node> list = newArrayList(path.iterator()); Collections.reverse(list); for (final Node node : list) { if (!isEmpty(node.getName())) { found = node; break; } } return found; }
public boolean isReachable(Object traversableObject, Path.Node traversableProperty, Class<?> rootBeanType, Path pathToTraversableObject, ElementType elementType) { //lazy, don't load return Hibernate.isInitialized( traversableObject ) && Hibernate.isPropertyInitialized( traversableObject, traversableProperty.getName() ); }
/** * {@inheritDoc} */ @Override public boolean isReachable(Object traversableObject, Path.Node traversableProperty, Class<?> rootBeanType, Path pathToTraversableObject, ElementType elementType) { return traversableObject == null || Persistence.getPersistenceUtil().isLoaded(traversableObject, traversableProperty.getName()); }
private void assertNode(Path.Node actualNode, String expectedName, ElementKind expectedKind, boolean expectedInIterable, Integer expectedIndex, Object expectedKey) { assertEquals( actualNode.getName(), expectedName ); assertEquals( actualNode.getKind(), expectedKind ); assertEquals( actualNode.isInIterable(), expectedInIterable ); assertEquals( actualNode.getIndex(), expectedIndex ); assertEquals( actualNode.getKey(), expectedKey ); }
/** * {@inheritDoc} */ public boolean isReachable(Object traversableObject, Path.Node traversableProperty, Class<?> rootBeanType, Path pathToTraversableObject, ElementType elementType) { return traversableObject == null || Persistence.getPersistenceUtil() .isLoaded(traversableObject, traversableProperty.getName()); }
public boolean isReachable(Object traversableObject, Path.Node traversableProperty, Class<?> rootBeanType, Path pathToTraversableObject, ElementType elementType) { //lazy, don't load return Hibernate.isInitialized( traversableObject ) && Hibernate.isPropertyInitialized( traversableObject, traversableProperty.getName() ); }
@Test public void testBlankGroupName() { final Group blankGroup = mock(Group.class); when(blankGroup.getName()).thenReturn(""); final Set<ConstraintViolation<Group>> violations1 = new GroupValidatorTestImpl().validate(blankGroup); assertTrue(violations1.size() == 1); final ConstraintViolation<Group> violation = violations1.iterator().next(); assertEquals(violation.getPropertyPath().iterator().next().getName(), "name"); assertEquals(violation.getMessage(), GroupValidator.KEY_NAME_NOT_EMPTY); }
private PropertyMetaData getBeanPropertyMetaData(BeanMetaData<?> beanMetaData, Path.Node propertyNode ) { if ( !ElementKind.PROPERTY.equals( propertyNode.getKind() ) ) { throw LOG.getInvalidPropertyPathException( beanMetaData.getBeanClass(), propertyNode.getName() ); } return beanMetaData.getMetaDataFor( propertyNode.getName() ); }
String fieldName = firstNode.getName(); try
private PathExpectation(Path propertyPath) { for ( Path.Node node : propertyPath ) { Integer parameterIndex = null; if ( node.getKind() == ElementKind.PARAMETER ) { parameterIndex = node.as( Path.ParameterNode.class ).getParameterIndex(); } Class<?> containerClass = getContainerClass( node ); Integer typeArgumentIndex = getTypeArgumentIndex( node ); nodes.add( new NodeExpectation( node.getName(), node.getKind(), node.isInIterable(), node.getKey(), node.getIndex(), parameterIndex, containerClass, typeArgumentIndex ) ); } }
private String getStringBasedPath(Path.Node traversableProperty, Path pathToTraversableObject) { StringBuilder path = new StringBuilder( ); for ( Path.Node node : pathToTraversableObject ) { if (node.getName() != null) { path.append( node.getName() ).append( "." ); } } if ( traversableProperty.getName() == null ) { throw new AssertionFailure( "TraversableResolver being passed a traversableProperty with null name. pathToTraversableObject: " + path.toString() ); } path.append( traversableProperty.getName() ); return path.toString(); }
public boolean isReachable(Object traversableObject, Path.Node traversableProperty, Class<?> rootBeanType, Path pathToTraversableObject, ElementType elementType) { //lazy, don't load return Hibernate.isInitialized( traversableObject ) && Hibernate.isPropertyInitialized( traversableObject, traversableProperty.getName() ); }
Path.Node next = iter.next(); if (next.getKind() == ElementKind.PROPERTY) { final String fieldName = next.getName(); final Field theField = beanClazz.getDeclaredField(fieldName);
@Override public boolean isReachable(final Object traversableObject, final Path.Node traversableProperty, final Class<?> rootBeanType, final Path pathToTraversableObject, final ElementType elementType) { // Make sure only getters on entities are validated (not getters on resource classes). final Class<?> traversableObjectClass = traversableObject.getClass(); final boolean isEntity = !rootBeanType.equals(traversableObjectClass); if (isEntity && validateExecutable && ElementType.METHOD.equals(elementType)) { final String propertyName = traversableProperty.getName(); final String propertyKey = traversableObjectClass.getName() + "#" + propertyName; if (!propertyToMethod.containsKey(propertyKey)) { final Method getter = getGetterMethod(traversableObjectClass, propertyName); if (getter != null) { propertyToMethod.putIfAbsent(propertyKey, getter); } } final Method getter = propertyToMethod.get(propertyKey); return getter != null && validateOnExecutionHandler.validateGetter(traversableObjectClass, getter); } return delegate.isReachable(traversableObject, traversableProperty, rootBeanType, pathToTraversableObject, elementType); }
/** * Gets a method parameter (or a parameter field) name, if the violation raised in it. */ private static Optional<String> getMemberName(ConstraintViolation<?> violation, Invocable invocable) { final List<Path.Node> propertyPath = Lists.of(violation.getPropertyPath()); final int size = propertyPath.size(); if (size < 2) { return Optional.empty(); } final Path.Node parent = propertyPath.get(size - 2); final Path.Node member = propertyPath.get(size - 1); switch (parent.getKind()) { case PARAMETER: // Constraint violation most likely failed with a BeanParam final List<Parameter> parameters = invocable.getParameters(); final Parameter param = parameters.get(parent.as(Path.ParameterNode.class).getParameterIndex()); // Extract the failing *Param annotation inside the Bean Param if (param.getSource().equals(Parameter.Source.BEAN_PARAM)) { final Field field = FieldUtils.getField(param.getRawType(), member.getName(), true); return JerseyParameterNameProvider.getParameterNameFromAnnotations(field.getDeclaredAnnotations()); } break; case METHOD: return Optional.of(member.getName()); default: break; } return Optional.empty(); }
public boolean isReachable(Object traversableObject, Path.Node traversableProperty, Class<?> rootBeanType, Path pathToTraversableObject, ElementType elementType) { //lazy, don't load return Hibernate.isInitialized( traversableObject ) && Hibernate.isPropertyInitialized( traversableObject, traversableProperty.getName() ); }