Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  
  package org.richfaces.validator;
  
 import java.util.Map;
 import java.util.Set;
 
 import  javax.faces.FacesException;
 import  javax.faces.application.FacesMessage;
 import  javax.faces.context.FacesContext;
 import  javax.validation.ConstraintViolation;
 import  javax.validation.Validator;
 import  javax.validation.metadata.ConstraintDescriptor;
 import  javax.validation.metadata.ElementDescriptor.ConstraintFinder;
 import  javax.validation.metadata.PropertyDescriptor;
 
 import  org.richfaces.el.ValueDescriptor;
 import  org.richfaces.el.ValueExpressionAnalayser;
 
 import  com.google.common.collect.ImmutableSet;

Author(s):
asmirnov
 
 public class BeanValidatorServiceImpl implements BeanValidatorService {
     private static final Collection<StringHIDDEN_PARAMS = ImmutableSet.of("message""payload""groups");
     private static final String FACES_CONTEXT_IS_NULL = "Faces context is null";
     private static final String INPUT_PARAMETERS_IS_NOT_CORRECT = "Input parameters is not correct.";
     private static final Class<?>[] DEFAULT_GROUP = {};
     private final ValueExpressionAnalayser analayser;
     private final BeanValidatorFactory validatorFactory;
 
     public BeanValidatorServiceImpl(ValueExpressionAnalayser analayser, BeanValidatorFactory validatorFactory) {
         this. = analayser;
         this. = validatorFactory;
     }
 
     /*
      * (non-Javadoc)
      *
      * @see org.richfaces.validator.BeanValidatorService#getConstrains(javax.faces.context.FacesContext,
      * javax.el.ValueExpression, java.lang.Class<?>[])
      */
     public Collection<ValidatorDescriptor> getConstrains(FacesContext contextValueExpression expressionString message,
         Class<?>... groups) {
         try {
             ValueDescriptor propertyDescriptor = .getPropertyDescriptor(contextexpression);
 
             if (propertyDescriptor == null) {
                 return Collections.emptySet();
             }
 
             return processBeanAttribute(contextpropertyDescriptormessagegroups);
         } catch (ELException e) {
             return Collections.emptySet();
         }
     }
 
     private Validator getValidator(FacesContext context) {
         return .getValidator(context);
     }
 
     Collection<ValidatorDescriptor> processBeanAttribute(FacesContext context, ValueDescriptor descriptorString msg,
         Class<?>... groups) {
         PropertyDescriptor constraintsForProperty = getValidator(context).getConstraintsForClass(descriptor.getBeanType())
             .getConstraintsForProperty(descriptor.getName());
         if (null != constraintsForProperty) {
             ConstraintFinder propertyConstraints = constraintsForProperty.findConstraints();
             if (null != groups && groups.length > 0) {
                 // Filter groups, if required
                 propertyConstraints = propertyConstraints.unorderedAndMatchingGroups(groups);
             }
             Set<ConstraintDescriptor<?>> constraints = propertyConstraints // or the requested list of groups)
                 .getConstraintDescriptors();
 
             // ContextHolder is an arbitrary object, it will depend on the implementation
             FacesMessage message = Strings.isEmpty(msg) ? null : new FacesMessage(FacesMessage.SEVERITY_ERROR, msgmsg);
             return processConstraints(contextconstraintsmessage);
         } else {
             return Collections.emptySet();
         }
     }
 
     Collection<ValidatorDescriptor> processConstraints(FacesContext contextSet<ConstraintDescriptor<?>> constraints,
         FacesMessage msg) {
         Set<ValidatorDescriptor> descriptors = new HashSet<ValidatorDescriptor>(constraints.size());
         for (ConstraintDescriptor<?> cd : constraints) {
            Annotation a = cd.getAnnotation();
            Map<StringObjectparameters = cd.getAttributes();
            // TODO if cd.isReportedAsSingleConstraint() make sure than only the root constraint raises an error message
            // if one or several of the composing constraints are invalid)
            FacesMessage message = null == msg ? .interpolateMessage(contextcd) : msg;
            Class<? extends AnnotationvalidatorClass = findAnnotationClass(a);
            BeanValidatorDescriptor beanValidatorDescriptor = new BeanValidatorDescriptor(validatorClassmessage);
            for (Map.Entry<StringObjectentry : parameters.entrySet()) {
                String key = entry.getKey();
                if (!.contains(key)) {
                    Object value = entry.getValue();
                    try {
                        Method method = validatorClass.getDeclaredMethod(key);
                        Object defaultValue = method.getDefaultValue();
                        if (!value.equals(defaultValue)) {
                            beanValidatorDescriptor.addParameter(keyvalue);
                        }
                    } catch (SecurityException e) {
                        beanValidatorDescriptor.addParameter(keyvalue);
                    } catch (NoSuchMethodException e) {
                        beanValidatorDescriptor.addParameter(keyvalue);
                    }
                }
            }
            beanValidatorDescriptor.makeImmutable();
            descriptors.add(beanValidatorDescriptor);
            descriptors.addAll(processConstraints(contextcd.getComposingConstraints(), msg)); // process the composing
                                                                                                // constraints
        }
        return descriptors;
    }
    private Class<? extends AnnotationfindAnnotationClass(Annotation a) {
        Class<? extends AnnotationannotationClass = a.getClass();
        // RF-10311, Hibernate validator wraps annotation class with proxy;
        if (!annotationClass.isAnnotation()) {
            Class<?>[] interfaces = annotationClass.getInterfaces();
            for (Class<?> implemented : interfaces) {
                if (implemented.isAnnotation()) {
                    annotationClass = (Class<? extends Annotation>) implemented;
                }
            }
        }
        return annotationClass;
    }
    public Collection<StringvalidateExpression(FacesContext contextValueExpression expressionObject newValue,
        Class<?>... groups) {
        if (null == context) {
            throw new FacesException();
        }
        Collection<StringvalidationMessages = null;
        if (null != expression) {
            ValueDescriptor valueDescriptor;
            try {
                valueDescriptor = .updateValueAndGetPropertyDescriptor(contextexpressionnewValue);
            } catch (ELException e) {
                throw new FacesException(e);
            }
            if (valueDescriptor != null) {
                validationMessages = validate(contextvalueDescriptor.getBeanType(), valueDescriptor.getName(), newValue,
                    groups);
            }
        }
        if (validationMessages == null) {
            validationMessages = Collections.emptySet();
        }
        return validationMessages;
    }

    
Class for identify validator instance by locale

Author(s):
amarkhel
    protected static class ValidatorKey {
        private final Class<? extends ObjectvalidatableClass;
        private final Locale locale;

        
Constructor for ValidatorKey object

Parameters:
validatableClass - class to validate
locale - User locale to determine Resource bundle, used during validation process
        public ValidatorKey(Class<? extends ObjectvalidatableClassLocale locale) {
            this. = validatableClass;
            this. = locale;
        }
        /*
         * (non-Javadoc)
         *
         * @see java.lang.Object#hashCode()
         */
        @Override
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + ((this. == null) ? 0 : this..hashCode());
            result = prime * result + ((this. == null) ? 0 : this..hashCode());
            return result;
        }
        /*
         * (non-Javadoc)
         *
         * @see java.lang.Object#equals(java.lang.Object)
         */
        @Override
        public boolean equals(Object obj) {
            if (this == obj) {
                return true;
            }
            if (obj == null) {
                return false;
            }
            if (getClass() != obj.getClass()) {
                return false;
            }
            ValidatorKey other = (ValidatorKeyobj;
            if (this. == null) {
                if (other.locale != null) {
                    return false;
                }
            } else if (!this..equals(other.locale)) {
                return false;
            }
            if (this. == null) {
                if (other.validatableClass != null) {
                    return false;
                }
            } else if (!this..equals(other.validatableClass)) {
                return false;
            }
            return true;
        }
    }
    protected Collection<Stringvalidate(FacesContext facesContextClass<?> beanTypeString propertyObject value,
        Class<?>[] groups) {
        @SuppressWarnings("unchecked")
        Set<ConstraintViolation<Object>> constrains = getValidator(facesContext).validateValue((Class<Object>) beanType,
            propertyvaluegetGroups(groups));
        return extractMessages(constrains);
    }
    private Class<?>[] getGroups(Class<?>[] groups) {
        return null == groups ?  : groups;
    }
    public Collection<StringvalidateObject(FacesContext contextObject valueClass<?>... groups) {
        Set<ConstraintViolation<Object>> violations = getValidator(context).validate(valuegetGroups(groups));
        Collection<Stringmessages = extractMessages(violations);
        return messages;
    }
    private Collection<StringextractMessages(Set<ConstraintViolation<Object>> violations) {
        Collection<Stringmessages;
        if (null != violations && violations.size() > 0) {
            messages = new ArrayList<String>(violations.size());
            for (ConstraintViolation<? extends ObjectconstraintViolation : violations) {
                messages.add(constraintViolation.getMessage());
            }
        } else {
            messages = Collections.emptySet();
        }
        return messages;
    }
New to GrepCode? Check out our FAQ X