/*
* Copyright 2010 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package com.google.gwt.validation.client.impl;
import com.google.gwt.validation.client.impl.metadata.BeanMetadata;
import com.google.gwt.validation.client.impl.metadata.MessageAndPath;
import com.google.gwt.validation.client.impl.metadata.ValidationGroupsMetadata;
import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.validation.ConstraintValidator;
import javax.validation.ConstraintViolation;
import javax.validation.MessageInterpolator;
import javax.validation.ValidationException;
import javax.validation.groups.Default;
/**
* Base methods for implementing a {@link GwtSpecificValidator}.
* <p>
* All methods that do not need to be generated go here.
*
* @param <G> the type object to validate
*/
public abstract class AbstractGwtSpecificValidator<G> implements
GwtSpecificValidator<G> {
/**
* Builds attributes one at a time.
* <p>
* Used to create a attribute map for annotations.
*/
public static final class AttributeBuilder {
private final HashMap<String, Object> tempMap = new HashMap<String, Object>();
private AttributeBuilder() {
}
public Map<String, Object> build() {
return Collections.unmodifiableMap(tempMap);
}
public AttributeBuilder put(String key, Object value) {
tempMap.put(key, value);
return this;
}
}
public static AttributeBuilder attributeBuilder() {
return new AttributeBuilder();
}
protected static Class<?>[] groupsToClasses(Group... groups) {
int numGroups = groups.length;
Class<?>[] array = new Class<?>[numGroups];
for (int i = 0; i < numGroups; i++) {
array[i] = groups[i].getGroup();
}
return array;
}
@Override
public <T> Set<ConstraintViolation<T>> validate(
GwtValidationContext<T> context,
G object,
Class<?>... groups) {
context.addValidatedObject(object);
try {
GroupValidator classGroupValidator = new ClassGroupValidator(object);
GroupChain groupChain = createGroupChainFromGroups(context, groups);
BeanMetadata beanMetadata = getBeanMetadata();
List<Class<?>> defaultGroupSeq = beanMetadata.getDefaultGroupSequence();
if (beanMetadata.defaultGroupSequenceIsRedefined()) {
// only need to check this on class-level validation
groupChain.checkDefaultGroupSequenceIsExpandable(defaultGroupSeq);
}
return validateGroups(context, classGroupValidator, groupChain);
} catch (IllegalArgumentException e) {
throw e;
} catch (ValidationException e) {
throw e;
} catch (Exception e) {
throw new ValidationException("Error validating " + object.getClass(), e);
}
}
@Override
public <T> Set<ConstraintViolation<T>> validateProperty(
GwtValidationContext<T> context,
G object,
String propertyName,
Class<?>... groups) throws ValidationException {
try {
GroupValidator propertyGroupValidator = new PropertyGroupValidator(object, propertyName);
GroupChain groupChain = createGroupChainFromGroups(context, groups);
return validateGroups(context, propertyGroupValidator, groupChain);
} catch (IllegalArgumentException e) {
throw e;
} catch (ValidationException e) {
throw e;
} catch (Exception e) {
throw new ValidationException("Error validating property " + propertyName +
" of " + object.getClass(), e);
}
}
@Override
public <T> Set<ConstraintViolation<T>> validateValue(
GwtValidationContext<T> context,
Class<G> beanType,
String propertyName,
Object value,
Class<?>... groups) throws ValidationException {
try {
GroupValidator valueGroupValidator = new ValueGroupValidator(beanType, propertyName, value);
GroupChain groupChain = createGroupChainFromGroups(context, groups);
return validateGroups(context, valueGroupValidator, groupChain);
} catch (IllegalArgumentException e) {
throw e;
} catch (ValidationException e) {
throw e;
} catch (Exception e) {
throw new ValidationException("Error validating property " + propertyName +
" with value " + value + " of " + beanType, e);
}
}
protected List<Class<?>> addDefaultGroupWhenEmpty(List<Class<?>> groups) {
if (groups.isEmpty()) {
groups = new ArrayList<Class<?>>();
groups.add(Default.class);
}
return groups;
}
protected <V, T, A extends Annotation> void addSingleViolation(
GwtValidationContext<T> context, Set<ConstraintViolation<T>> violations,
G object, V value, ConstraintDescriptorImpl<A> constraintDescriptor) {
ConstraintValidatorContextImpl<A, V> constraintValidatorContext =
context.createConstraintValidatorContext(constraintDescriptor);
addViolations(context, violations, object, value, constraintDescriptor,
constraintValidatorContext);
}
/**
* Perform the actual validation of a single {@link ConstraintValidator}.
* <p>
* As a side effect {@link ConstraintViolation}s may be added to
* {@code violations}.
*
* @return true if there was any constraint violations
*/
protected <A extends Annotation, T, V> boolean validate(
GwtValidationContext<T> context, Set<ConstraintViolation<T>> violations,
G object, V value, ConstraintValidator<A, ? super V> validator,
ConstraintDescriptorImpl<A> constraintDescriptor, Class<?>... groups) {
validator.initialize(constraintDescriptor.getAnnotation());
ConstraintValidatorContextImpl<A, V> constraintValidatorContext =
context.createConstraintValidatorContext(constraintDescriptor);
List<Class<?>> groupsList = Arrays.asList(groups);
ValidationGroupsMetadata validationGroupsMetadata =
context.getValidator().getValidationGroupsMetadata();
Set<Class<?>> constraintGroups = constraintDescriptor.getGroups();
// check groups requested are in the set of constraint groups (including the implicit group)
if (!containsAny(groupsList, constraintGroups)
&& !groupsList.contains(getConstraints(validationGroupsMetadata).getElementClass())) {
return false;
}
if (!validator.isValid(value, constraintValidatorContext)) {
addViolations(//
context, //
violations, //
object, //
value, //
constraintDescriptor, //
constraintValidatorContext);
return true;
}
return false;
}
private <V, T, A extends Annotation> void addViolations(
GwtValidationContext<T> context, Set<ConstraintViolation<T>> violations,
G object, V value, ConstraintDescriptorImpl<A> constraintDescriptor,
ConstraintValidatorContextImpl<A, V> constraintValidatorContext) {
Set<MessageAndPath> mps = constraintValidatorContext.getMessageAndPaths();
for (MessageAndPath messageAndPath : mps) {
ConstraintViolation<T> violation = createConstraintViolation(//
context, //
object, //
value, //
constraintDescriptor, //
messageAndPath);
violations.add(violation);
}
}
private <T> boolean containsAny(Collection<T> left, Collection<T> right) {
for (T t : left) {
if (right.contains(t)) {
return true;
}
}
return false;
}
private <T, V, A extends Annotation> ConstraintViolation<T> createConstraintViolation(
GwtValidationContext<T> context, G object, V value,
ConstraintDescriptorImpl<A> constraintDescriptor,
MessageAndPath messageAndPath) {
MessageInterpolator messageInterpolator = context.getMessageInterpolator();
com.google.gwt.validation.client.impl.MessageInterpolatorContextImpl messageContext = new MessageInterpolatorContextImpl(
constraintDescriptor, value);
String message = messageInterpolator.interpolate(
messageAndPath.getMessage(), messageContext);
ConstraintViolation<T> violation = ConstraintViolationImpl.<T> builder() //
.setConstraintDescriptor(constraintDescriptor) //
.setInvalidValue(value) //
.setLeafBean(object) //
.setMessage(message) //
.setMessageTemplate(messageAndPath.getMessage()) //
.setPropertyPath(messageAndPath.getPath()) //
.setRootBean(context.getRootBean()) //
.setRootBeanClass(context.getRootBeanClass()) //
.setElementType(constraintDescriptor.getElementType()) //
.build();
return violation;
}
private <T> GroupChain createGroupChainFromGroups(GwtValidationContext<T> context, Class<?>... groups) {
List<Class<?>> groupsList = addDefaultGroupWhenEmpty(Arrays.asList(groups));
ValidationGroupsMetadata validationGroupsMetadata =
context.getValidator().getValidationGroupsMetadata();
return new GroupChainGenerator(validationGroupsMetadata).getGroupChainFor(groupsList);
}
/**
* Performs the top-level validation using a helper {@link GroupValidator}. This takes
* group sequencing and Default group overriding into account.
*/
private <T> Set<ConstraintViolation<T>> validateGroups(
GwtValidationContext<T> context,
GroupValidator groupValidator,
GroupChain groupChain) {
Set<ConstraintViolation<T>> violations = new HashSet<ConstraintViolation<T>>();
Collection<Group> allGroups = groupChain.getAllGroups();
Group[] allGroupsArray = allGroups.toArray(new Group[allGroups.size()]);
groupValidator.validateGroups(context, violations, allGroupsArray);
// handle sequences
Iterator<List<Group>> sequenceIterator = groupChain.getSequenceIterator();
while (sequenceIterator.hasNext()) {
List<Group> sequence = sequenceIterator.next();
for (Group group : sequence) {
int numberOfViolations = violations.size();
groupValidator.validateGroups(context, violations, group);
if (violations.size() > numberOfViolations) {
// stop processing when an error occurs
break;
}
}
}
return violations;
}
private class ClassGroupValidator implements GroupValidator {
private final G object;
public ClassGroupValidator(G object) {
this.object = object;
}
@Override
public <T> void validateGroups(GwtValidationContext<T> context,
Set<ConstraintViolation<T>> violations, Group... groups) {
expandDefaultAndValidateClassGroups(context, object, violations, groups);
}
}
private class PropertyGroupValidator implements GroupValidator {
private final G object;
private final String propertyName;
public PropertyGroupValidator(G object, String propertyName) {
this.object = object;
this.propertyName = propertyName;
}
@Override
public <T> void validateGroups(GwtValidationContext<T> context,
Set<ConstraintViolation<T>> violations, Group... groups) {
expandDefaultAndValidatePropertyGroups(context, object, propertyName, violations, groups);
}
}
private class ValueGroupValidator implements GroupValidator {
private final Class<G> beanType;
private final String propertyName;
private final Object value;
public ValueGroupValidator(Class<G> beanType, String propertyName, Object value) {
this.beanType = beanType;
this.propertyName = propertyName;
this.value = value;
}
@Override
public <T> void validateGroups(GwtValidationContext<T> context,
Set<ConstraintViolation<T>> violations, Group... groups) {
expandDefaultAndValidateValueGroups(context, beanType, propertyName, value, violations, //
groups);
}
}
}