View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  package org.apache.commons.validator;
18  
19  import org.apache.commons.validator.util.ValidatorUtils;
20  
21  /**
22   * Contains validation methods for different unit tests.
23   */
24  public class GenericValidatorImpl {
25  
26      public final static String FIELD_TEST_NULL = "NULL";
27  
28      public final static String FIELD_TEST_NOTNULL = "NOTNULL";
29  
30      public final static String FIELD_TEST_EQUAL = "EQUAL";
31  
32      private static boolean isStringOrNull(final Object o) {
33          if (o == null) {
34              return true; // TODO this condition is not exercised by any tests currently
35          }
36          return o instanceof String;
37      }
38  
39      /**
40       * Checks if the field can be successfully converted to a <code>byte</code>.
41       *
42       * @param bean  The value validation is being performed on.
43       * @param field the field to use
44       * @return boolean If the field can be successfully converted to a <code>byte</code> {@code true} is returned. Otherwise {@code false}.
45       */
46      public static boolean validateByte(final Object bean, final Field field) {
47          final String value = ValidatorUtils.getValueAsString(bean, field.getProperty());
48  
49          return GenericValidator.isByte(value);
50      }
51  
52      /**
53       * Checks if the field can be successfully converted to a <code>double</code>.
54       *
55       * @param bean  The value validation is being performed on.
56       * @param field the field to use
57       * @return boolean If the field can be successfully converted to a <code>double</code> {@code true} is returned. Otherwise {@code false}.
58       */
59      public static boolean validateDouble(final Object bean, final Field field) {
60          final String value = ValidatorUtils.getValueAsString(bean, field.getProperty());
61  
62          return GenericValidator.isDouble(value);
63      }
64  
65      /**
66       * Checks if the field is an e-mail address.
67       *
68       * @param bean  The value validation is being performed on.
69       * @param field the field to use
70       * @return boolean If the field is an e-mail address {@code true} is returned. Otherwise {@code false}.
71       */
72      public static boolean validateEmail(final Object bean, final Field field) {
73          final String value = ValidatorUtils.getValueAsString(bean, field.getProperty());
74  
75          return GenericValidator.isEmail(value);
76      }
77  
78      /**
79       * Checks if the field can be successfully converted to a <code>float</code>.
80       *
81       * @param bean  The value validation is being performed on.
82       * @param field the field to use
83       * @return boolean If the field can be successfully converted to a <code>float</code> {@code true} is returned. Otherwise {@code false}.
84       */
85      public static boolean validateFloat(final Object bean, final Field field) {
86          final String value = ValidatorUtils.getValueAsString(bean, field.getProperty());
87  
88          return GenericValidator.isFloat(value);
89      }
90  
91      /**
92       * Checks if the field can be successfully converted to a <code>int</code>.
93       *
94       * @param bean  The value validation is being performed on.
95       * @param field the field to use
96       * @return boolean If the field can be successfully converted to a <code>int</code> {@code true} is returned. Otherwise {@code false}.
97       */
98      public static boolean validateInt(final Object bean, final Field field) {
99          final String value = ValidatorUtils.getValueAsString(bean, field.getProperty());
100 
101         return GenericValidator.isInt(value);
102     }
103 
104     /**
105      * Checks if the field can be successfully converted to a <code>long</code>.
106      *
107      * @param bean  The value validation is being performed on.
108      * @param field the field to use
109      * @return boolean If the field can be successfully converted to a <code>long</code> {@code true} is returned. Otherwise {@code false}.
110      */
111     public static boolean validateLong(final Object bean, final Field field) {
112         final String value = ValidatorUtils.getValueAsString(bean, field.getProperty());
113 
114         return GenericValidator.isLong(value);
115     }
116 
117     /**
118      * Checks if field is positive assuming it is an integer
119      *
120      * @param bean  The value validation is being performed on.
121      * @param field Description of the field to be evaluated
122      * @return boolean If the integer field is greater than zero, returns true, otherwise returns false.
123      */
124     public static boolean validatePositive(final Object bean, final Field field) {
125         final String value = ValidatorUtils.getValueAsString(bean, field.getProperty());
126 
127         return GenericTypeValidator.formatInt(value).intValue() > 0;
128     }
129 
130     /**
131      * Throws a runtime exception if the value of the argument is "RUNTIME", an exception if the value of the argument is "CHECKED", and a ValidatorException
132      * otherwise.
133      *
134      * @throws RuntimeException   with "RUNTIME-EXCEPTION as message" if value is "RUNTIME"
135      * @throws Exception          with "CHECKED-EXCEPTION" as message if value is "CHECKED"
136      * @throws ValidatorException with "VALIDATOR-EXCEPTION" as message otherwise
137      */
138     public static boolean validateRaiseException(final Object bean, final Field field) throws Exception {
139 
140         final String value = ValidatorUtils.getValueAsString(bean, field.getProperty());
141 
142         if ("RUNTIME".equals(value)) {
143             throw new RuntimeException("RUNTIME-EXCEPTION");
144 
145         }
146         if ("CHECKED".equals(value)) {
147             throw new Exception("CHECKED-EXCEPTION");
148 
149         }
150         throw new ValidatorException("VALIDATOR-EXCEPTION");
151     }
152 
153     /**
154      * Checks if the field is required.
155      *
156      * @return boolean If the field isn't <code>null</code> and has a length greater than zero, {@code true} is returned. Otherwise {@code false}.
157      */
158     public static boolean validateRequired(final Object bean, final Field field) {
159         final String value = ValidatorUtils.getValueAsString(bean, field.getProperty());
160 
161         return !GenericValidator.isBlankOrNull(value);
162     }
163 
164     public static boolean validateRequiredIf(final Object bean, final Field field, final Validator validator) {
165 
166         final Object form = validator.getParameterValue(Validator.BEAN_PARAM);
167         String value = null;
168         boolean required = false;
169         if (isStringOrNull(bean)) {
170             value = (String) bean;
171         } else {
172             value = ValidatorUtils.getValueAsString(bean, field.getProperty());
173         }
174         int i = 0;
175         String fieldJoin = "AND";
176         if (!GenericValidator.isBlankOrNull(field.getVarValue("fieldJoin"))) {
177             fieldJoin = field.getVarValue("fieldJoin");
178         }
179         if (fieldJoin.equalsIgnoreCase("AND")) {
180             required = true;
181         }
182         while (!GenericValidator.isBlankOrNull(field.getVarValue("field[" + i + "]"))) {
183             String dependProp = field.getVarValue("field[" + i + "]");
184             final String dependTest = field.getVarValue("fieldTest[" + i + "]");
185             final String dependTestValue = field.getVarValue("fieldValue[" + i + "]");
186             String dependIndexed = field.getVarValue("fieldIndexed[" + i + "]");
187             if (dependIndexed == null) {
188                 dependIndexed = "false";
189             }
190             boolean this_required = false;
191             if (field.isIndexed() && dependIndexed.equalsIgnoreCase("true")) {
192                 final String key = field.getKey();
193                 if (key.contains("[") && key.contains("]")) {
194                     final String ind = key.substring(0, key.indexOf(".") + 1);
195                     dependProp = ind + dependProp;
196                 }
197             }
198             final String dependVal = ValidatorUtils.getValueAsString(form, dependProp);
199             if (dependTest.equals(FIELD_TEST_NULL)) {
200                 if (dependVal != null && !dependVal.isEmpty()) {
201                     this_required = false;
202                 } else {
203                     this_required = true;
204                 }
205             }
206             if (dependTest.equals(FIELD_TEST_NOTNULL)) {
207                 if (dependVal != null && !dependVal.isEmpty()) {
208                     this_required = true;
209                 } else {
210                     this_required = false;
211                 }
212             }
213             if (dependTest.equals(FIELD_TEST_EQUAL)) {
214                 this_required = dependTestValue.equalsIgnoreCase(dependVal);
215             }
216             if (fieldJoin.equalsIgnoreCase("AND")) {
217                 required = required && this_required;
218             } else {
219                 required = required || this_required;
220             }
221             i++;
222         }
223         if (required) {
224             if (value != null && !value.isEmpty()) {
225                 return true;
226             }
227             return false;
228         }
229         return true;
230     }
231 
232     /**
233      * Checks if the field can be successfully converted to a <code>short</code>.
234      *
235      * @param bean  The value validation is being performed on.
236      * @param field the field to use
237      * @return boolean If the field can be successfully converted to a <code>short</code> {@code true} is returned. Otherwise {@code false}.
238      */
239     public static boolean validateShort(final Object bean, final Field field) {
240         final String value = ValidatorUtils.getValueAsString(bean, field.getProperty());
241 
242         return GenericValidator.isShort(value);
243     }
244 
245 }