Coverage Report

Coverage Report - org.kuali.rice.krad.datadictionary.validation.ValidationUtils

Classes in this File

Line Coverage

Branch Coverage

Complexity

ValidationUtils

0/181

0/195

8.667

ValidationUtils$1

0/1

N/A

8.667

ValidationUtils$Result

0/1

N/A

8.667

 /**
  * Copyright 2005-2011 The Kuali Foundation
  *
  * Licensed under the Educational Community 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.opensource.org/licenses/ecl2.php
  *
  * 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.kuali.rice.krad.datadictionary.validation;
 
 import org.apache.commons.lang.StringUtils;
 import org.kuali.rice.core.api.datetime.DateTimeService;
 import org.kuali.rice.core.api.uif.DataType;
 import org.kuali.rice.krad.datadictionary.exception.AttributeValidationException;
 
 import java.math.BigDecimal;
 import java.text.ParseException;
 import java.util.Collection;
 import java.util.Date;
 
 /**
  * Inherited from Kuali Student and adapted extensively, this class provides static utility methods for validation processing. 
  * 
  * @author Kuali Rice Team (rice.collab@kuali.org)
  */
 public class ValidationUtils {
 
         public static String buildPath(String attributePath, String attributeName) {
                 if (StringUtils.isNotBlank(attributeName)) {
                         if (StringUtils.isNotBlank(attributePath)) 
                                 return new StringBuilder(attributePath).append(".").append(attributeName).toString();
                 
                         return attributeName;
                 }
                 return attributePath;
         }
         
         /**
          * Used to get the rightmost index value of an attribute path.
          *  
          * @param attributePath
          * @return the right index of value of attribute path, -1 if path has no index
          */
         public static int getLastPathIndex(String attributePath){
             int index = -1;
             
             int leftBracket = attributePath.lastIndexOf("[");
             int rightBracket = attributePath.lastIndexOf("]");
             
             if (leftBracket > 0 && rightBracket > leftBracket){
                 String indexString = attributePath.substring(leftBracket +1, rightBracket);
                 try {
                 index = Integer.valueOf(indexString).intValue();
             } catch (NumberFormatException e) {
                 // Will just return -1
             }
             }
             
             return index;
         }
         
         public static boolean compareValues(Object value1, Object value2,
                         DataType dataType, String operator, boolean isCaseSensitive, DateTimeService dateTimeService) {
 
                 boolean result = false;
                 Integer compareResult = null;
 
                 if("has_value".equalsIgnoreCase(operator)){
                         if(value1==null){
                                 return "false".equals(value2.toString().toLowerCase());
                         }
                         if (value1 instanceof String && ((String) value1).isEmpty()){
                             return "false".equals(value2.toString().toLowerCase());                            
                         }
                         if(value1 instanceof Collection && ((Collection<?>) value1).isEmpty()){
                                 return "false".equals(value2.toString().toLowerCase());
                         }
                         return "true".equals(value2.toString().toLowerCase());
                 }                
                 // Convert objects into appropriate data types
                 if (null != dataType) {
                         if (DataType.STRING.equals(dataType)) {
                             String v1 = getString(value1);
                                 String v2 = getString(value2);
 
                                 if(!isCaseSensitive) {
                                     v1 = v1.toUpperCase();
                                     v2 = v2.toUpperCase();
                                 }
                                 
                                 compareResult = v1.compareTo(v2);
                         } else if (DataType.INTEGER.equals(dataType)) {
                                 Integer v1 = getInteger(value1);
                                 Integer v2 = getInteger(value2);
                                 compareResult = v1.compareTo(v2);
                         } else if (DataType.LONG.equals(dataType)) {
                                 Long v1 = getLong(value1);
                                 Long v2 = getLong(value2);
                                 compareResult = v1.compareTo(v2);
                         } else if (DataType.DOUBLE.equals(dataType)) {
                                 Double v1 = getDouble(value1);
                                 Double v2 = getDouble(value2);
                                 compareResult = v1.compareTo(v2);
                         } else if (DataType.FLOAT.equals(dataType)) {
                                 Float v1 = getFloat(value1);
                                 Float v2 = getFloat(value2);
                                 compareResult = v1.compareTo(v2);
                         } else if (DataType.BOOLEAN.equals(dataType)) {
                                 Boolean v1 = getBoolean(value1);
                                 Boolean v2 = getBoolean(value2);
                                 compareResult = v1.compareTo(v2);
                         } else if (DataType.DATE.equals(dataType)) {
                                 Date v1 = getDate(value1, dateTimeService);
                                 Date v2 = getDate(value2, dateTimeService);
                                 compareResult = v1.compareTo(v2);
                         }
                 }
 
                 if (null != compareResult) {
                         if (("equals".equalsIgnoreCase(operator)
                                         || "greater_than_equal".equalsIgnoreCase(operator) || "less_than_equal"
                                         .equalsIgnoreCase(operator))
                                         && 0 == compareResult) {
                                 result = true;
                         }
 
                         if (("not_equal".equalsIgnoreCase (operator)
      || "greater_than".equalsIgnoreCase(operator)) && compareResult >= 1) {
                                 result = true;
                         }
 
                         if (("not_equal".equalsIgnoreCase (operator)
      || "less_than".equalsIgnoreCase(operator)) && compareResult <= -1) {
                                 result = true;
                         }
                 }
 
                 return result;
         }
 
         public static Integer getInteger(Object o) {
                 Integer result = null;
                 if (o instanceof Integer)
                         return (Integer) o;
                 if (o == null)
                         return null;
                 if (o instanceof Number)
                         return ((Number) o).intValue();
                 String s = o.toString();
                 if (s != null && s.trim().length() > 0) {
                         result = Integer.valueOf(s.trim());
                 }
                 return result;
         }
 
         public static Long getLong(Object o) {
                 Long result = null;
                 if (o instanceof Long)
                         return (Long) o;
                 if (o == null)
                         return null;
                 if (o instanceof Number)
                         return ((Number) o).longValue();
                 String s = o.toString();
                 if (s != null && s.trim().length() > 0) {
                         result = Long.valueOf(s.trim());
                 }
                 return result;
         }
 
         public static Float getFloat(Object o) {
                 Float result = null;
                 if (o instanceof Float)
                         return (Float) o;
                 if (o == null)
                         return null;
                 if (o instanceof Number)
                         return ((Number) o).floatValue();
                 String s = o.toString();
                 if (s != null && s.trim().length() > 0) {
                         result = Float.valueOf(s.trim());
                 }
                 return result;
         }
 
         public static Double getDouble(Object o) {
                 Double result = null;
                 if (o instanceof BigDecimal)
                         return ((BigDecimal) o).doubleValue();
                 if (o instanceof Double)
                         return (Double) o;
                 if (o == null)
                         return null;
                 if (o instanceof Number)
                         return ((Number) o).doubleValue();
                 String s = o.toString();
                 if (s != null && s.trim().length() > 0) {
                         result = Double.valueOf(s.trim());
                 }
                 return result;
         }
 
         public static Date getDate(Object o, DateTimeService dateTimeService) throws IllegalArgumentException {
                 Date result = null;
                 if (o instanceof Date)
                         return (Date) o;
                 if (o == null)
                         return null;
                 String s = o.toString();
                 if (s != null && s.trim().length() > 0) {
                         try {
                                 result = dateTimeService.convertToDate(s.trim());
                         } catch (ParseException e) {
                                 throw new IllegalArgumentException(e);
                         } 
                 }
                 return result;
         }
 
         public static String getString(Object o) {
                 if (o instanceof String)
                         return (String) o;
                 if (o == null)
                         return null;
                 return o.toString();
         }
 
         public static Boolean getBoolean(Object o) {
                 Boolean result = null;
                 if (o instanceof Boolean)
                         return (Boolean) o;
                 if (o == null)
                         return null;
                 String s = o.toString();
                 if (s != null && s.trim().length() > 0) {
                         result = Boolean.parseBoolean(s.trim());
                 }
                 return result;
         }        
         
 
     public static boolean hasText(String string) {
 
         if (string == null || string.length() < 1) {
             return false;
         }
         int stringLength = string.length();
 
         for (int i = 0; i < stringLength; i++) {
             char currentChar = string.charAt(i);
             if (' ' != currentChar || '\t' != currentChar || '\n' != currentChar) {
                 return true;
             }
         }
 
         return false;
     }
     
     public static boolean isNullOrEmpty(Object value) {
             return value == null || (value instanceof String && StringUtils.isBlank(((String) value).trim()));
     }
     
         
         public static enum Result { VALID, INVALID, UNDEFINED };
         
         public static Object convertToDataType(Object value, DataType dataType, DateTimeService dateTimeService) throws AttributeValidationException {
                 Object returnValue = value;
                 
                 if (null == value)
                         return null;
                 
                 switch (dataType) {
                 case BOOLEAN:
                         if (! (value instanceof Boolean)) {
                                 returnValue = Boolean.valueOf(value.toString());
                                 
                                 // Since the Boolean.valueOf is exceptionally loose - it basically takes any string and makes it false
                                 if (!value.toString().equalsIgnoreCase("TRUE") && !value.toString().equalsIgnoreCase("FALSE"))
                                         throw new AttributeValidationException("Value " + value.toString() + " is not a boolean!");
                         }
                         break;
                 case INTEGER:
                         if (! (value instanceof Number)) {
                                 returnValue = Integer.valueOf(value.toString());
                         }
                         break;
                 case LONG:
                         if (! (value instanceof Number)) {
                                 returnValue = Long.valueOf(value.toString());
                         }
                         break;
                 case DOUBLE:
                         if (! (value instanceof Number)) {
                                 returnValue = Double.valueOf(value.toString());
                         }
                         if (((Double)returnValue).isNaN())
                                 throw new AttributeValidationException("Infinite Double values are not valid!");                
                         if (((Double)returnValue).isInfinite())
                                 throw new AttributeValidationException("Infinite Double values are not valid!");
                         break;
                 case FLOAT:
                         if (! (value instanceof Number)) {
                                 returnValue = Float.valueOf(value.toString());
                         }
                         if (((Float)returnValue).isNaN())
                                 throw new AttributeValidationException("NaN Float values are not valid!");
                         if (((Float)returnValue).isInfinite())
                                 throw new AttributeValidationException("Infinite Float values are not valid!");
                         break;
                 case TRUNCATED_DATE:
                 case DATE:
                         if (! (value instanceof Date)) {
                                 try {
                                         returnValue = dateTimeService.convertToDate(value.toString());
                                 } catch (ParseException pe) {
                                         throw new AttributeValidationException("Value " + value.toString() + " is not a date!");
                                 }
                         }
                         break;
                 case STRING:
                 }
                 
                 return returnValue;
         }
         
         public static <T> Result isGreaterThan(T value, Comparable<T> limit) {
                 return limit == null ? Result.UNDEFINED : ( limit.compareTo(value) < 0 ? Result.VALID : Result.INVALID );
         }
         
         public static <T> Result isGreaterThanOrEqual(T value, Comparable<T> limit) {
                 return limit == null ? Result.UNDEFINED : ( limit.compareTo(value) <= 0 ? Result.VALID : Result.INVALID );
         }
         
         public static <T> Result isLessThan(T value, Comparable<T> limit) {
                 return limit == null ? Result.UNDEFINED : ( limit.compareTo(value) > 0 ? Result.VALID : Result.INVALID );
         }
         
         public static <T> Result isLessThanOrEqual(T value, Comparable<T> limit) {
                 return limit == null ? Result.UNDEFINED : ( limit.compareTo(value) >= 0 ? Result.VALID : Result.INVALID );
         }
         
         
     public static String[] getPathTokens(String fieldPath) {
         return (fieldPath != null && fieldPath.contains(".") ? fieldPath.split("\\.") : new String[]{fieldPath});
     }
 
 }
 

1		/**
2		* Copyright 2005-2011 The Kuali Foundation
3		*
4		* Licensed under the Educational Community License, Version 2.0 (the "License");
5		* you may not use this file except in compliance with the License.
6		* You may obtain a copy of the License at
7		*
8		* http://www.opensource.org/licenses/ecl2.php
9		*
10		* Unless required by applicable law or agreed to in writing, software
11		* distributed under the License is distributed on an "AS IS" BASIS,
12		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13		* See the License for the specific language governing permissions and
14		* limitations under the License.
15		*/
16		package org.kuali.rice.krad.datadictionary.validation;
17
18		import org.apache.commons.lang.StringUtils;
19		import org.kuali.rice.core.api.datetime.DateTimeService;
20		import org.kuali.rice.core.api.uif.DataType;
21		import org.kuali.rice.krad.datadictionary.exception.AttributeValidationException;
22
23		import java.math.BigDecimal;
24		import java.text.ParseException;
25		import java.util.Collection;
26		import java.util.Date;
27
28		/**
29		* Inherited from Kuali Student and adapted extensively, this class provides static utility methods for validation processing.
30		*
31		* @author Kuali Rice Team (rice.collab@kuali.org)
32		*/
33	0	public class ValidationUtils {
34
35		public static String buildPath(String attributePath, String attributeName) {
36	0	if (StringUtils.isNotBlank(attributeName)) {
37	0	if (StringUtils.isNotBlank(attributePath))
38	0	return new StringBuilder(attributePath).append(".").append(attributeName).toString();
39
40	0	return attributeName;
41		}
42	0	return attributePath;
43		}
44
45		/**
46		* Used to get the rightmost index value of an attribute path.
47		*
48		* @param attributePath
49		* @return the right index of value of attribute path, -1 if path has no index
50		*/
51		public static int getLastPathIndex(String attributePath){
52	0	int index = -1;
53
54	0	int leftBracket = attributePath.lastIndexOf("[");
55	0	int rightBracket = attributePath.lastIndexOf("]");
56
57	0	if (leftBracket > 0 && rightBracket > leftBracket){
58	0	String indexString = attributePath.substring(leftBracket +1, rightBracket);
59		try {
60	0	index = Integer.valueOf(indexString).intValue();
61	0	} catch (NumberFormatException e) {
62		// Will just return -1
63	0	}
64		}
65
66	0	return index;
67		}
68
69		public static boolean compareValues(Object value1, Object value2,
70		DataType dataType, String operator, boolean isCaseSensitive, DateTimeService dateTimeService) {
71
72	0	boolean result = false;
73	0	Integer compareResult = null;
74
75	0	if("has_value".equalsIgnoreCase(operator)){
76	0	if(value1==null){
77	0	return "false".equals(value2.toString().toLowerCase());
78		}
79	0	if (value1 instanceof String && ((String) value1).isEmpty()){
80	0	return "false".equals(value2.toString().toLowerCase());
81		}
82	0	if(value1 instanceof Collection && ((Collection<?>) value1).isEmpty()){
83	0	return "false".equals(value2.toString().toLowerCase());
84		}
85	0	return "true".equals(value2.toString().toLowerCase());
86		}
87		// Convert objects into appropriate data types
88	0	if (null != dataType) {
89	0	if (DataType.STRING.equals(dataType)) {
90	0	String v1 = getString(value1);
91	0	String v2 = getString(value2);
92
93	0	if(!isCaseSensitive) {
94	0	v1 = v1.toUpperCase();
95	0	v2 = v2.toUpperCase();
96		}
97
98	0	compareResult = v1.compareTo(v2);
99	0	} else if (DataType.INTEGER.equals(dataType)) {
100	0	Integer v1 = getInteger(value1);
101	0	Integer v2 = getInteger(value2);
102	0	compareResult = v1.compareTo(v2);
103	0	} else if (DataType.LONG.equals(dataType)) {
104	0	Long v1 = getLong(value1);
105	0	Long v2 = getLong(value2);
106	0	compareResult = v1.compareTo(v2);
107	0	} else if (DataType.DOUBLE.equals(dataType)) {
108	0	Double v1 = getDouble(value1);
109	0	Double v2 = getDouble(value2);
110	0	compareResult = v1.compareTo(v2);
111	0	} else if (DataType.FLOAT.equals(dataType)) {
112	0	Float v1 = getFloat(value1);
113	0	Float v2 = getFloat(value2);
114	0	compareResult = v1.compareTo(v2);
115	0	} else if (DataType.BOOLEAN.equals(dataType)) {
116	0	Boolean v1 = getBoolean(value1);
117	0	Boolean v2 = getBoolean(value2);
118	0	compareResult = v1.compareTo(v2);
119	0	} else if (DataType.DATE.equals(dataType)) {
120	0	Date v1 = getDate(value1, dateTimeService);
121	0	Date v2 = getDate(value2, dateTimeService);
122	0	compareResult = v1.compareTo(v2);
123		}
124		}
125
126	0	if (null != compareResult) {
127	0	if (("equals".equalsIgnoreCase(operator)
128		\|\| "greater_than_equal".equalsIgnoreCase(operator) \|\| "less_than_equal"
129		.equalsIgnoreCase(operator))
130		&& 0 == compareResult) {
131	0	result = true;
132		}
133
134	0	if (("not_equal".equalsIgnoreCase (operator)
135		\|\| "greater_than".equalsIgnoreCase(operator)) && compareResult >= 1) {
136	0	result = true;
137		}
138
139	0	if (("not_equal".equalsIgnoreCase (operator)
140		\|\| "less_than".equalsIgnoreCase(operator)) && compareResult <= -1) {
141	0	result = true;
142		}
143		}
144
145	0	return result;
146		}
147
148		public static Integer getInteger(Object o) {
149	0	Integer result = null;
150	0	if (o instanceof Integer)
151	0	return (Integer) o;
152	0	if (o == null)
153	0	return null;
154	0	if (o instanceof Number)
155	0	return ((Number) o).intValue();
156	0	String s = o.toString();
157	0	if (s != null && s.trim().length() > 0) {
158	0	result = Integer.valueOf(s.trim());
159		}
160	0	return result;
161		}
162
163		public static Long getLong(Object o) {
164	0	Long result = null;
165	0	if (o instanceof Long)
166	0	return (Long) o;
167	0	if (o == null)
168	0	return null;
169	0	if (o instanceof Number)
170	0	return ((Number) o).longValue();
171	0	String s = o.toString();
172	0	if (s != null && s.trim().length() > 0) {
173	0	result = Long.valueOf(s.trim());
174		}
175	0	return result;
176		}
177
178		public static Float getFloat(Object o) {
179	0	Float result = null;
180	0	if (o instanceof Float)
181	0	return (Float) o;
182	0	if (o == null)
183	0	return null;
184	0	if (o instanceof Number)
185	0	return ((Number) o).floatValue();
186	0	String s = o.toString();
187	0	if (s != null && s.trim().length() > 0) {
188	0	result = Float.valueOf(s.trim());
189		}
190	0	return result;
191		}
192
193		public static Double getDouble(Object o) {
194	0	Double result = null;
195	0	if (o instanceof BigDecimal)
196	0	return ((BigDecimal) o).doubleValue();
197	0	if (o instanceof Double)
198	0	return (Double) o;
199	0	if (o == null)
200	0	return null;
201	0	if (o instanceof Number)
202	0	return ((Number) o).doubleValue();
203	0	String s = o.toString();
204	0	if (s != null && s.trim().length() > 0) {
205	0	result = Double.valueOf(s.trim());
206		}
207	0	return result;
208		}
209
210		public static Date getDate(Object o, DateTimeService dateTimeService) throws IllegalArgumentException {
211	0	Date result = null;
212	0	if (o instanceof Date)
213	0	return (Date) o;
214	0	if (o == null)
215	0	return null;
216	0	String s = o.toString();
217	0	if (s != null && s.trim().length() > 0) {
218		try {
219	0	result = dateTimeService.convertToDate(s.trim());
220	0	} catch (ParseException e) {
221	0	throw new IllegalArgumentException(e);
222	0	}
223		}
224	0	return result;
225		}
226
227		public static String getString(Object o) {
228	0	if (o instanceof String)
229	0	return (String) o;
230	0	if (o == null)
231	0	return null;
232	0	return o.toString();
233		}
234
235		public static Boolean getBoolean(Object o) {
236	0	Boolean result = null;
237	0	if (o instanceof Boolean)
238	0	return (Boolean) o;
239	0	if (o == null)
240	0	return null;
241	0	String s = o.toString();
242	0	if (s != null && s.trim().length() > 0) {
243	0	result = Boolean.parseBoolean(s.trim());
244		}
245	0	return result;
246		}
247
248
249		public static boolean hasText(String string) {
250
251	0	if (string == null \|\| string.length() < 1) {
252	0	return false;
253		}
254	0	int stringLength = string.length();
255
256	0	for (int i = 0; i < stringLength; i++) {
257	0	char currentChar = string.charAt(i);
258	0	if (' ' != currentChar \|\| '\t' != currentChar \|\| '\n' != currentChar) {
259	0	return true;
260		}
261		}
262
263	0	return false;
264		}
265
266		public static boolean isNullOrEmpty(Object value) {
267	0	return value == null \|\| (value instanceof String && StringUtils.isBlank(((String) value).trim()));
268		}
269
270
271	0	public static enum Result { VALID, INVALID, UNDEFINED };
272
273		public static Object convertToDataType(Object value, DataType dataType, DateTimeService dateTimeService) throws AttributeValidationException {
274	0	Object returnValue = value;
275
276	0	if (null == value)
277	0	return null;
278
279	0	switch (dataType) {
280		case BOOLEAN:
281	0	if (! (value instanceof Boolean)) {
282	0	returnValue = Boolean.valueOf(value.toString());
283
284		// Since the Boolean.valueOf is exceptionally loose - it basically takes any string and makes it false
285	0	if (!value.toString().equalsIgnoreCase("TRUE") && !value.toString().equalsIgnoreCase("FALSE"))
286	0	throw new AttributeValidationException("Value " + value.toString() + " is not a boolean!");
287		}
288		break;
289		case INTEGER:
290	0	if (! (value instanceof Number)) {
291	0	returnValue = Integer.valueOf(value.toString());
292		}
293		break;
294		case LONG:
295	0	if (! (value instanceof Number)) {
296	0	returnValue = Long.valueOf(value.toString());
297		}
298		break;
299		case DOUBLE:
300	0	if (! (value instanceof Number)) {
301	0	returnValue = Double.valueOf(value.toString());
302		}
303	0	if (((Double)returnValue).isNaN())
304	0	throw new AttributeValidationException("Infinite Double values are not valid!");
305	0	if (((Double)returnValue).isInfinite())
306	0	throw new AttributeValidationException("Infinite Double values are not valid!");
307		break;
308		case FLOAT:
309	0	if (! (value instanceof Number)) {
310	0	returnValue = Float.valueOf(value.toString());
311		}
312	0	if (((Float)returnValue).isNaN())
313	0	throw new AttributeValidationException("NaN Float values are not valid!");
314	0	if (((Float)returnValue).isInfinite())
315	0	throw new AttributeValidationException("Infinite Float values are not valid!");
316		break;
317		case TRUNCATED_DATE:
318		case DATE:
319	0	if (! (value instanceof Date)) {
320		try {
321	0	returnValue = dateTimeService.convertToDate(value.toString());
322	0	} catch (ParseException pe) {
323	0	throw new AttributeValidationException("Value " + value.toString() + " is not a date!");
324	0	}
325		}
326		break;
327		case STRING:
328		}
329
330	0	return returnValue;
331		}
332
333		public static <T> Result isGreaterThan(T value, Comparable<T> limit) {
334	0	return limit == null ? Result.UNDEFINED : ( limit.compareTo(value) < 0 ? Result.VALID : Result.INVALID );
335		}
336
337		public static <T> Result isGreaterThanOrEqual(T value, Comparable<T> limit) {
338	0	return limit == null ? Result.UNDEFINED : ( limit.compareTo(value) <= 0 ? Result.VALID : Result.INVALID );
339		}
340
341		public static <T> Result isLessThan(T value, Comparable<T> limit) {
342	0	return limit == null ? Result.UNDEFINED : ( limit.compareTo(value) > 0 ? Result.VALID : Result.INVALID );
343		}
344
345		public static <T> Result isLessThanOrEqual(T value, Comparable<T> limit) {
346	0	return limit == null ? Result.UNDEFINED : ( limit.compareTo(value) >= 0 ? Result.VALID : Result.INVALID );
347		}
348
349
350		public static String[] getPathTokens(String fieldPath) {
351	0	return (fieldPath != null && fieldPath.contains(".") ? fieldPath.split("\\.") : new String[]{fieldPath});
352		}
353
354		}
355