001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: */
017: package org.apache.cocoon.woody.datatype.validationruleimpl;
018:
019: import org.apache.cocoon.woody.datatype.ValidationRule;
020: import org.apache.cocoon.woody.datatype.ValidationError;
021: import org.apache.cocoon.woody.formmodel.CannotYetResolveWarning;
022: import org.apache.excalibur.xml.sax.XMLizable;
023: import org.outerj.expression.Expression;
024: import org.outerj.expression.ExpressionContext;
025: import org.outerj.expression.ExpressionException;
026:
027: import java.math.BigDecimal;
028:
029: /**
030: * Abstract base class providing common functionality for many {@link ValidationRule}
031: * implementations.
032: *
033: * @version $Id: AbstractValidationRule.java 433543 2006-08-22 06:22:54Z crossley $
034: */
035: public abstract class AbstractValidationRule implements ValidationRule {
036: private XMLizable failMessage;
037:
038: /**
039: * Sets the failmessage to use for this validation rule, this will be used
040: * instead of the validation rules' built-in message. The message itself should
041: * be an object impementing XMLizable, such as a SaxBuffer instance. This
042: * allows fail messages to contain mixed content (instead of just
043: * being a string).
044: */
045: public void setFailMessage(XMLizable object) {
046: this .failMessage = object;
047: }
048:
049: /**
050: * Returns the failMessage wrapped in a ValidationError object.
051: */
052: public ValidationError getFailMessage() {
053: return new ValidationError(failMessage);
054: }
055:
056: /**
057: * Returns true if this validation rule has a user-defined fail message.
058: */
059: public boolean hasFailMessage() {
060: return failMessage != null;
061: }
062:
063: /**
064: * Helper method for evaluating expressions whose result is numeric.
065: *
066: * @param exprName a name for the expression that's descriptive for the user, e.g. the name of the attribute in which it was defined
067: * @param ruleName a descriptive name for the validation rule, usually the rule's element name
068: * @return either a ValidationError (because expression evaluation failed) or a CannotYetResolveWarning
069: * (because another, required field referenced in the expression has not yet a value), or a BigDecimal.
070: */
071: protected Object evaluateNumeric(Expression expression,
072: ExpressionContext expressionContext, String exprName,
073: String ruleName) {
074: Object expressionResult;
075: try {
076: expressionResult = expression.evaluate(expressionContext);
077: } catch (CannotYetResolveWarning w) {
078: return w;
079: } catch (ExpressionException e) {
080: return new ValidationError("Error evaluating \"" + exprName
081: + "\" expression on \"" + ruleName
082: + "\" validation rule", false);
083: }
084:
085: if (!(expressionResult instanceof BigDecimal)) {
086: return new ValidationError("Got non-numeric result from \""
087: + exprName + "\" expression on \"" + ruleName
088: + "\" validation rule", false);
089: }
090:
091: return expressionResult;
092: }
093:
094: /**
095: * Helper method for evaluating expressions whose result is comparable.
096: *
097: * @param exprName a name for the expression that's descriptive for the user, e.g. the name of the attribute in which it was defined
098: * @param ruleName a descriptive name for the validation rule, usually the rule's element name
099: * @return either a ValidationError (because expression evaluation failed) or a CannotYetResolveWarning
100: * (because another, required field referenced in the expression has not yet a value), or a BigDecimal.
101: */
102: protected Object evaluateComparable(Expression expression,
103: ExpressionContext expressionContext, String exprName,
104: String ruleName) {
105: Object expressionResult;
106: try {
107: expressionResult = expression.evaluate(expressionContext);
108: } catch (CannotYetResolveWarning w) {
109: return w;
110: } catch (ExpressionException e) {
111: return new ValidationError("Error evaluating \"" + exprName
112: + "\" expression on \"" + ruleName
113: + "\" validation rule", false);
114: }
115:
116: if (!(expressionResult instanceof Comparable)) {
117: return new ValidationError(
118: "Got non-comparable result from \"" + exprName
119: + "\" expression on \"" + ruleName
120: + "\" validation rule", false);
121: }
122:
123: return expressionResult;
124: }
125: }
|