001// Copyright 2010, 2012 The Apache Software Foundation
002//
003// Licensed under the Apache License, Version 2.0 (the "License");
004// you may not use this file except in compliance with the License.
005// You may obtain a copy of the License at
006//
007//     http://www.apache.org/licenses/LICENSE-2.0
008//
009// Unless required by applicable law or agreed to in writing, software
010// distributed under the License is distributed on an "AS IS" BASIS,
011// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
012// See the License for the specific language governing permissions and
013// limitations under the License.
014package org.apache.tapestry5.internal.beanvalidator;
015
016import org.apache.tapestry5.Field;
017import org.apache.tapestry5.FieldValidator;
018import org.apache.tapestry5.MarkupWriter;
019import org.apache.tapestry5.ValidationException;
020import org.apache.tapestry5.beanvalidator.BeanValidatorGroupSource;
021import org.apache.tapestry5.beanvalidator.ClientConstraintDescriptor;
022import org.apache.tapestry5.beanvalidator.ClientConstraintDescriptorSource;
023import org.apache.tapestry5.internal.BeanValidationContext;
024import org.apache.tapestry5.ioc.internal.util.CollectionFactory;
025import org.apache.tapestry5.services.Environment;
026import org.apache.tapestry5.services.FormSupport;
027
028import javax.validation.ConstraintViolation;
029import javax.validation.MessageInterpolator;
030import javax.validation.MessageInterpolator.Context;
031import javax.validation.Validator;
032import javax.validation.ValidatorFactory;
033import javax.validation.metadata.BeanDescriptor;
034import javax.validation.metadata.ConstraintDescriptor;
035import javax.validation.metadata.PropertyDescriptor;
036
037import java.lang.annotation.Annotation;
038import java.util.Iterator;
039import java.util.Map;
040import java.util.Set;
041
042import static java.lang.String.format;
043
044
045public class BeanFieldValidator implements FieldValidator
046{
047    private final Field field;
048    private final ValidatorFactory validatorFactory;
049    private final BeanValidatorGroupSource beanValidationGroupSource;
050    private final ClientConstraintDescriptorSource clientValidatorSource;
051    private final FormSupport formSupport;
052    private final Environment environment;
053
054    public BeanFieldValidator(Field field,
055                              ValidatorFactory validatorFactory,
056                              BeanValidatorGroupSource beanValidationGroupSource,
057                              ClientConstraintDescriptorSource clientValidatorSource,
058                              FormSupport formSupport,
059                              Environment environment)
060    {
061        this.field = field;
062        this.validatorFactory = validatorFactory;
063        this.beanValidationGroupSource = beanValidationGroupSource;
064        this.clientValidatorSource = clientValidatorSource;
065        this.formSupport = formSupport;
066        this.environment = environment;
067    }
068
069    @Override
070    public boolean isRequired()
071    {
072        return false;
073    }
074
075    @Override
076    public void render(final MarkupWriter writer)
077    {
078        final BeanValidationContext beanValidationContext = environment.peek(BeanValidationContext.class);
079
080        if (beanValidationContext == null)
081        {
082            return;
083        }
084
085        final Validator validator = validatorFactory.getValidator();
086
087        final String currentProperty = beanValidationContext.getCurrentProperty();
088
089        if (currentProperty == null) return;
090        
091        final ValidationInfo validationInfo = getValidationInfo(beanValidationContext, currentProperty, validator);
092        final PropertyDescriptor propertyDescriptor = validationInfo.getPropertyDescriptor();
093
094        if (propertyDescriptor == null) return;
095
096        for (final ConstraintDescriptor<?> descriptor : propertyDescriptor.getConstraintDescriptors())
097        {
098            Class<? extends Annotation> annotationType = descriptor.getAnnotation().annotationType();
099
100            ClientConstraintDescriptor clientConstraintDescriptor = clientValidatorSource.getConstraintDescriptor(annotationType);
101
102            if (clientConstraintDescriptor == null)
103            {
104                continue;
105            }
106
107            String message = format("%s %s", field.getLabel(), interpolateMessage(descriptor));
108
109            Map<String, Object> attributes = CollectionFactory.newMap();
110
111            for (String attribute : clientConstraintDescriptor.getAttributes())
112            {
113                Object object = descriptor.getAttributes().get(attribute);
114
115                if (object == null)
116                {
117                    throw new NullPointerException(
118                            String.format("Attribute '%s' of %s is null but is required to apply client-side validation.",
119                                    attribute, descriptor));
120                }
121                attributes.put(attribute, object);
122            }
123
124            clientConstraintDescriptor.applyClientValidation(writer, message, attributes);
125        }
126    }
127
128    @Override
129    @SuppressWarnings("unchecked")
130    public void validate(final Object value) throws ValidationException
131    {
132
133        final BeanValidationContext beanValidationContext = environment.peek(BeanValidationContext.class);
134
135        if (beanValidationContext == null)
136        {
137            return;
138        }
139
140        final Validator validator = validatorFactory.getValidator();
141
142        String currentProperty = beanValidationContext.getCurrentProperty();
143
144        if (currentProperty == null) return;
145        
146        final ValidationInfo validationInfo = getValidationInfo(beanValidationContext, currentProperty, validator);
147        final PropertyDescriptor propertyDescriptor = validationInfo.getPropertyDescriptor();
148
149        if (propertyDescriptor == null) return;
150
151        final Set<ConstraintViolation<Object>> violations = validator.validateValue(
152                (Class<Object>) validationInfo.getBeanType(), validationInfo.getPropertyName(),
153                value, beanValidationGroupSource.get());
154
155        if (violations.isEmpty())
156        {
157            return;
158        }
159
160        final StringBuilder builder = new StringBuilder();
161
162        for (Iterator<ConstraintViolation<Object>> iterator = violations.iterator(); iterator.hasNext(); )
163        {
164            ConstraintViolation<?> violation = iterator.next();
165
166            builder.append(format("%s %s", field.getLabel(), violation.getMessage()));
167
168            if (iterator.hasNext())
169                builder.append(", ");
170
171        }
172
173        throw new ValidationException(builder.toString());
174
175    }
176
177    /**
178     * Returns the class of a given property, but only if it is a constrained property of the
179     * parent class. Otherwise, it returns null.
180     */
181    final private static Class<?> getConstrainedPropertyClass(BeanDescriptor beanDescriptor, String propertyName)
182    {
183        Class<?> clasz = null;
184        for (PropertyDescriptor descriptor : beanDescriptor.getConstrainedProperties()) 
185        {
186            if (descriptor.getPropertyName().equals(propertyName)) 
187            {
188                clasz = descriptor.getElementClass();
189                break;
190            }
191        }
192        return clasz;
193    }
194
195    private String interpolateMessage(final ConstraintDescriptor<?> descriptor)
196    {
197        String messageTemplate = (String) descriptor.getAttributes().get("message");
198
199        MessageInterpolator messageInterpolator = validatorFactory.getMessageInterpolator();
200
201        return messageInterpolator.interpolate(messageTemplate, new Context()
202        {
203
204            @Override
205            public ConstraintDescriptor<?> getConstraintDescriptor()
206            {
207                return descriptor;
208            }
209
210            @Override
211            public Object getValidatedValue()
212            {
213                return null;
214            }
215        });
216    }
217    
218    final private static ValidationInfo getValidationInfo(BeanValidationContext beanValidationContext, String currentProperty, Validator validator) {
219        Class<?> beanType = beanValidationContext.getBeanType();
220        String[] path = currentProperty.split("\\.");
221        BeanDescriptor beanDescriptor = validator.getConstraintsForClass(beanType);
222        
223        for (int i = 1; i < path.length - 1; i++) 
224        {
225            Class<?> constrainedPropertyClass = getConstrainedPropertyClass(beanDescriptor, path[i]);
226            if (constrainedPropertyClass != null) {
227                beanType = constrainedPropertyClass;
228                beanDescriptor = validator.getConstraintsForClass(beanType);
229            }
230        }
231
232        final String propertyName = path[path.length - 1];
233        PropertyDescriptor propertyDescriptor = beanDescriptor.getConstraintsForProperty(propertyName);
234        return new ValidationInfo(beanType, propertyName, propertyDescriptor);
235    }
236    
237    final private static class ValidationInfo {
238        final private Class<?> beanType;
239        final private String propertyName;
240        final private PropertyDescriptor propertyDescriptor;
241        public ValidationInfo(Class<?> beanType, String propertyName,
242                PropertyDescriptor propertyDescriptor) 
243        {
244            super();
245            this.beanType = beanType;
246            this.propertyName = propertyName;
247            this.propertyDescriptor = propertyDescriptor;
248        }
249        
250        public Class<?> getBeanType() 
251        {
252            return beanType;
253        }
254        
255        public String getPropertyName() 
256        {
257            return propertyName;
258        }
259
260        public PropertyDescriptor getPropertyDescriptor() 
261        {
262            return propertyDescriptor;
263        }
264
265    }
266    
267}