/*
* Copyright 2004-2005 the original author or authors.
*
* 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 org.springmodules.validation.bean.rule;
import java.beans.PropertyDescriptor;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.BeanWrapperImpl;
import org.springmodules.validation.util.condition.AbstractCondition;
import org.springmodules.validation.util.condition.Condition;
import org.springmodules.validation.util.condition.Conditions;
import org.springmodules.validation.bean.context.ValidationContextUtils;
/**
* A {@link ValidationRule} implementation that wraps another validation rule and is associated with a specific
* property name. This validation rule is applicable on an object only if the object has the associated property and
* if wrapped rule is applicable on the value of that property. The condition of the rule is condition of the wrapped
* rule applied on the value of the associated property of the object.
*
* @author Uri Boness
*/
public class PropertyValidationRule implements ValidationRule {
// the name of the associated property.
private String propertyName;
// the wrapped validation rule.
private ValidationRule rule;
private Condition applicabilityCondition;
private String[] contextTokens;
/**
* Constructs a new PropertyValidationRule (javabean support).
*/
public PropertyValidationRule() {
this(null, null);
}
/**
* Constructs a new PropertyValidationRule with a given property and a wrapped validation rule.
*
* @param propertyName The name of the associated property.
* @param rule The validation rule to be wrapped.
*/
public PropertyValidationRule(String propertyName, ValidationRule rule) {
this.propertyName = propertyName;
this.rule = rule;
applicabilityCondition = new DefaultApplicabilityCondition(propertyName, rule);
contextTokens = null;
}
/**
* Determines whether this rule is applicable on the given object. In practice, this validation rule is applicable
* only if the given object a property that match the property associated with this rule and if the wrapped rule
* is applicable on the value of that property.
*
* @param obj The object to be validated.
* @return <code>true</code> if this rule is applicable on the given object, <code>false</code> otherwise.
* @see ValidationRule#isApplicable(Object)
*/
public boolean isApplicable(Object obj) {
return checkContext(contextTokens) && applicabilityCondition.check(obj);
}
/**
* Returns the conditoin of this validation rule. In practice, applying this condition means applying the
* condition of the wrapped rule on the value of the associated property of the validated object.
*
* @return The condition of this validation rule.
* @see ValidationRule#getCondition()
*/
public Condition getCondition() {
return Conditions.property(propertyName, rule.getCondition());
}
/**
* Returns the error code of this condition. This error code is the same as the error code of the wrapped rule.
*
* @return The error code of this condition.
*/
public String getErrorCode() {
return rule.getErrorCode();
}
/**
* Returns the arguments for the error of this validation rule. These arguments are the same as the ones of the
* wrapped rule.
*
* @param obj The validated object.
* @return The arguments for the error of this validation rule.
*/
public Object[] getErrorArguments(Object obj) {
return rule.getErrorArguments(obj);
}
/**
* Returns the default error message of this validation rule. This error message is the same as the error message
* of the wrapped rule.
*
* @return The default error message of this validation rule.
*/
public String getDefaultErrorMessage() {
return rule.getDefaultErrorMessage();
}
public void setApplicabilityCondition(Condition applicabilityCondition) {
this.applicabilityCondition = applicabilityCondition;
}
public void setContextTokens(String[] contextTokens) {
this.contextTokens = contextTokens;
}
protected static boolean checkContext(String[] tokens) {
return ValidationContextUtils.tokensSupportedByCurrentContext(tokens);
}
//=================================================== Inner Classes ================================================
protected static class DefaultApplicabilityCondition extends AbstractCondition {
private String propertyName;
private ValidationRule rule;
public DefaultApplicabilityCondition(String propertyName, ValidationRule rule) {
this.propertyName = propertyName;
this.rule = rule;
}
public boolean doCheck(Object obj) {
PropertyDescriptor propertyDescriptor = BeanUtils.getPropertyDescriptor(obj.getClass(), propertyName);
if (propertyDescriptor == null) {
return false;
}
Object value = new BeanWrapperImpl(obj).getPropertyValue(propertyName);
return rule.isApplicable(value);
}
}
}