Refine search
Path path = violation.getPropertyPath(); StringBuilder sb = new StringBuilder(); boolean first = true; for (Path.Node node : path) { if (node.isInIterable()) { sb.append('['); Object index = node.getIndex(); if (index == null) { index = node.getKey(); String name = node.getName(); if (name != null && node.getKind() == ElementKind.PROPERTY && !name.startsWith("<")) { if (!first) { sb.append('.');
List<String> entries = new ArrayList<>(); Iterator<Node> it = violation.getPropertyPath().iterator(); while (it.hasNext()) { Node node = it.next(); if (ElementKind.PROPERTY == node.getKind() || (ElementKind.PARAMETER == node.getKind() && !it.hasNext())) { if (node.getKey() != null) { entries.add(node.getKey().toString()); entries.add(node.getName()); messages = new ArrayList<>(); messages.add(violation.getMessage()); errors = new HashMap<>(); errors.put(Joiner.on('.').join(entries), violation.getMessage());
message.append( ")" ); message.append( " Kind: " ); message.append( leafNode.getKind() ); if ( leafNode.getKind() == ElementKind.PARAMETER ) { message.append( "\n parameter index: " ); message.append( leafNode.as( Path.ParameterNode.class ).getParameterIndex() ); message.append( constraintViolation.getMessage() ); message.append( "\n root bean: " ); message.append( constraintViolation.getRootBean() ); message.append( "\n property path: " ); message.append( constraintViolation.getPropertyPath() ); message.append( "\n constraint: " ); message.append( constraintViolation.getConstraintDescriptor().getAnnotation() );
StringBuilder path = new StringBuilder(); try { Class<?> beanClazz = violation.getRootBeanClass(); final Iterator<Path.Node> iter = violation.getPropertyPath().iterator(); while (iter.hasNext()) { Path.Node next = iter.next(); if (next.getKind() == ElementKind.PROPERTY) { final String fieldName = next.getName(); final Field theField = beanClazz.getDeclaredField(fieldName); messages.add(StringUtils.format("%s - %s", path.toString(), violation.getMessage()));
@Override public ValidationErrorMessage createBody(ConstraintViolationException ex, HttpServletRequest req) { ErrorMessage tmpl = super.createBody(ex, req); ValidationErrorMessage msg = new ValidationErrorMessage(tmpl); for (ConstraintViolation<?> violation : ex.getConstraintViolations()) { Node pathNode = findLastNonEmptyPathNode(violation.getPropertyPath()); // path is probably useful only for properties (fields) if (pathNode != null && pathNode.getKind() == ElementKind.PROPERTY) { msg.addError(pathNode.getName(), convertToString(violation.getInvalidValue()), violation.getMessage()); // type level constraints etc. } else { msg.addError(violation.getMessage()); } } return msg; }
Iterator<Node> nodes = v.getPropertyPath().iterator(); Node firstNode = nodes.next(); if (firstNode.getKind() == ElementKind.METHOD) if (secondNode.getKind() == ElementKind.PARAMETER || secondNode.getKind() == ElementKind.CROSS_PARAMETER) else if (secondNode.getKind() == ElementKind.RETURN_VALUE) throw new RuntimeException(Messages.MESSAGES.unexpectedPathNodeViolation(secondNode.getKind())); if (firstNode.getKind() == ElementKind.BEAN) if (firstNode.getKind() == ElementKind.PROPERTY) String fieldName = firstNode.getName(); try getMethod(v.getRootBeanClass(), getterName); return ConstraintType.Type.PROPERTY; Method m = getMethod(v.getLeafBean().getClass(), getterName); if (m.getReturnType().equals(boolean.class)) throw new RuntimeException(Messages.MESSAGES.unexpectedPathNode(firstNode.getKind()));
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() ); }
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(); }
@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); }
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() ); }
private static Class<?> getContainerClass(Path.Node node) { Class<?> containerClass = null; if ( node.getKind() == ElementKind.PROPERTY ) { containerClass = node.as( Path.PropertyNode.class ).getContainerClass(); } if ( node.getKind() == ElementKind.BEAN ) { containerClass = node.as( Path.BeanNode.class ).getContainerClass(); } if ( node.getKind() == ElementKind.CONTAINER_ELEMENT ) { containerClass = node.as( Path.ContainerElementNode.class ).getContainerClass(); } return containerClass; }
private static Integer getTypeArgumentIndex(Path.Node node) { Integer typeArgumentIndex = null; if ( node.getKind() == ElementKind.PROPERTY ) { typeArgumentIndex = node.as( Path.PropertyNode.class ).getTypeArgumentIndex(); } if ( node.getKind() == ElementKind.BEAN ) { typeArgumentIndex = node.as( Path.BeanNode.class ).getTypeArgumentIndex(); } if ( node.getKind() == ElementKind.CONTAINER_ELEMENT ) { typeArgumentIndex = node.as( Path.ContainerElementNode.class ).getTypeArgumentIndex(); } return 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(); }
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 ) ); } }
if ( p1Node.getKind() != p2Node.getKind() ) { return false; if ( p2Node.getName() == null ) { if ( p1Node.getName() != null ) { return false; else if ( !p2Node.getName().equals( p1Node.getName() ) ) { return false; if ( p2Node.isInIterable() != p1Node.isInIterable() ) { return false; if ( p2Node.getIndex() == null ) { if ( p1Node.getIndex() != null ) { return false; else if ( !p2Node.getIndex().equals( p1Node.getIndex() ) ) { return false; if ( p2Node.getKey() == null ) { if ( p1Node.getKey() != null ) { return false; else if ( !p2Node.getKey().equals( p1Node.getKey() ) ) { return false; if ( p1Node.getKind() == ElementKind.PARAMETER ) { int p1NodeParameterIndex = p1Node.as( Path.ParameterNode.class ).getParameterIndex();
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 ); }
/** * Create a new NodeImpl instance. * @param node */ NodeImpl(Path.Node node) { this.name = node.getName(); this.inIterable = node.isInIterable(); this.index = node.getIndex(); this.key = node.getKey(); }
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() ); }
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() ); }