Coverage Report

Coverage Report - org.kuali.rice.kew.util.Utilities

Classes in this File

Line Coverage

Branch Coverage

Complexity

Utilities

0/51

0/18

4.3

Utilities$PrioritySorter

0/9

0/8

4.3

Utilities$RouteLogActionRequestSorter

0/13

0/14

4.3

 /**
  * 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.kew.util;
 
 import org.apache.commons.lang.text.StrSubstitutor;
 import org.kuali.rice.core.api.CoreApiServiceLocator;
 import org.kuali.rice.core.api.util.KeyValue;
 import org.kuali.rice.kew.actionrequest.ActionRequestValue;
 import org.kuali.rice.kew.api.KewApiConstants;
 import org.kuali.rice.kim.api.KimConstants;
 
 import java.util.Calendar;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
 
 /**
  * Various static utility methods.
  *
  * @author Kuali Rice Team (rice.collab@kuali.org)
  */
 public final class Utilities {
     /**
      * Commons-Lang StrSubstitor which substitutes variables specified like ${name} in strings,
      * using a lookup implementation that pulls variables from the core config
      */
     private static final StrSubstitutor SUBSTITUTOR = new StrSubstitutor(new ConfigStringLookup());
     
     private Utilities() {
             throw new UnsupportedOperationException("do not call");
     }
 
     /**
      * Performs variable substitution on the specified string, replacing variables specified like ${name}
      * with the value of the corresponding config parameter obtained from the current context Config object.
      * This version of the method also takes an application id to qualify the parameter.
      * @param applicationId the application id to use for qualifying the parameter
      * @param string the string on which to perform variable substitution
      * @return a string with any variables substituted with configuration parameter values
      */
     public static String substituteConfigParameters(String applicationId, String string) {
             StrSubstitutor sub = new StrSubstitutor(new ConfigStringLookup(applicationId));
         return sub.replace(string);
     }
         
     /**
      * Performs variable substitution on the specified string, replacing variables specified like ${name}
      * with the value of the corresponding config parameter obtained from the current context Config object
      * @param string the string on which to perform variable substitution
      * @return a string with any variables substituted with configuration parameter values
      */
     public static String substituteConfigParameters(String string) {
         return SUBSTITUTOR.replace(string);
     }
 
     public static String parseGroupNamespaceCode(String namespaceAndNameCombo) {
         if (namespaceAndNameCombo == null) {
             return null;
         }
         String[] groupData = namespaceAndNameCombo.split(KewApiConstants.KIM_GROUP_NAMESPACE_NAME_DELIMITER_CHARACTER);
         if (groupData.length == 1) {
             return KimConstants.KIM_GROUP_WORKFLOW_NAMESPACE_CODE;
         } else if (groupData.length == 2) {
             return groupData[0].trim();
         } else {
             return null;
         }
     }
 
     public static String parseGroupName(String namespaceAndNameCombo) {
         if (namespaceAndNameCombo == null) {
             return null;
         }
         String[] groupData = namespaceAndNameCombo.split(KewApiConstants.KIM_GROUP_NAMESPACE_NAME_DELIMITER_CHARACTER);
         if (groupData.length == 1) {
             return groupData[0].trim();
         } else if (groupData.length == 2) {
             return groupData[1].trim();
         } else {
             return null;
         }
     }
 
     /**
      *
      *        Consider moving out of this class if this bugs
      */
     public static class PrioritySorter implements Comparator<ActionRequestValue> {
         @Override
                 public int compare(ActionRequestValue ar1, ActionRequestValue ar2) {
             int value = ar1.getPriority().compareTo(ar2.getPriority());
             if (value == 0) {
                 value = ActionRequestValue.compareActionCode(ar1.getActionRequested(), ar2.getActionRequested(), true);
                 if (value == 0) {
                     if ( (ar1.getActionRequestId() != null) && (ar2.getActionRequestId() != null) ) {
                         value = ar1.getActionRequestId().compareTo(ar2.getActionRequestId());
                     } else {
                         // if even one action request id is null at this point return that the two are equal
                         value = 0;
                     }
                 }
             }
             return value;
         }
     }
 
     /**
      *
      *        Consider moving out of this class if this bugs
      */
     public static class RouteLogActionRequestSorter extends PrioritySorter implements Comparator<ActionRequestValue> {
         @Override
                 public int compare(ActionRequestValue ar1, ActionRequestValue ar2) {
             if (! ar1.getChildrenRequests().isEmpty()) {
                 Collections.sort(ar1.getChildrenRequests(), this);
             }
             if (! ar2.getChildrenRequests().isEmpty()) {
                 Collections.sort(ar2.getChildrenRequests(), this);
             }
 
             int routeLevelCompareVal = ar1.getRouteLevel().compareTo(ar2.getRouteLevel());
             if (routeLevelCompareVal != 0) {
                 return routeLevelCompareVal;
             }
 
             if (ar1.isActive() && ar2.isPending()) {
                 return -1;
             } else if (ar2.isActive() && ar1.isPending()) {
                 return 1;
             }
 
             return super.compare(ar1, ar2);
         }
     }
 
     public static boolean checkDateRanges(String fromDate, String toDate) {
         try {
             Date parsedDate = CoreApiServiceLocator.getDateTimeService().convertToDate(fromDate.trim());
             Calendar fromCalendar = Calendar.getInstance();
             fromCalendar.setLenient(false);
             fromCalendar.setTime(parsedDate);
             fromCalendar.set(Calendar.HOUR_OF_DAY, 0);
             fromCalendar.set(Calendar.MINUTE, 0);
             fromCalendar.set(Calendar.SECOND, 0);
             fromCalendar.set(Calendar.MILLISECOND, 0);
             parsedDate = CoreApiServiceLocator.getDateTimeService().convertToDate(toDate.trim());
             Calendar toCalendar = Calendar.getInstance();
             toCalendar.setLenient(false);
             toCalendar.setTime(parsedDate);
             toCalendar.set(Calendar.HOUR_OF_DAY, 0);
             toCalendar.set(Calendar.MINUTE, 0);
             toCalendar.set(Calendar.SECOND, 0);
             toCalendar.set(Calendar.MILLISECOND, 0);
             if (fromCalendar.after(toCalendar)) {
                 return false;
             }
             return true;
         } catch (Exception ex) {
             return false;
         }
     }
 
     /**
      * Helper method that takes a List of {@link KeyValue} and presents it as a Map
      * @param collection collection of {@link KeyValue}
      * @return a Map<String, String> representing the keys and values in the KeyValue collection
      */
     public static <T  extends KeyValue> Map<String, String> getKeyValueCollectionAsMap(List<T> collection) {
         Map<String, String> map = new HashMap<String, String>(collection.size());
         for (KeyValue kv: collection) {
             map.put(kv.getKey(), kv.getValue());
         }
         return map;
     }
 
     /**
      * Helper method that takes a List of {@link KeyValue} and presents it as a Map containing
      * KeyValue values
      * @param <T> the key type
      * @param collection collection of {@link KeyValue}
      * @return a Map<T,Z> where keys of the KeyValues in the collection are mapped to their respective KeyValue object
      */
     public static <T  extends KeyValue> Map<String, T> getKeyValueCollectionAsLookupTable(List<T> collection) {
         Map<String, T> map = new HashMap<String, T>(collection.size());
         for (T kv: collection) {
             map.put(kv.getKey(), kv);
         }
         return map;
     }
 }

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.kew.util;
17
18		import org.apache.commons.lang.text.StrSubstitutor;
19		import org.kuali.rice.core.api.CoreApiServiceLocator;
20		import org.kuali.rice.core.api.util.KeyValue;
21		import org.kuali.rice.kew.actionrequest.ActionRequestValue;
22		import org.kuali.rice.kew.api.KewApiConstants;
23		import org.kuali.rice.kim.api.KimConstants;
24
25		import java.util.Calendar;
26		import java.util.Collections;
27		import java.util.Comparator;
28		import java.util.Date;
29		import java.util.HashMap;
30		import java.util.List;
31		import java.util.Map;
32
33
34		/**
35		* Various static utility methods.
36		*
37		* @author Kuali Rice Team (rice.collab@kuali.org)
38		*/
39		public final class Utilities {
40		/**
41		* Commons-Lang StrSubstitor which substitutes variables specified like ${name} in strings,
42		* using a lookup implementation that pulls variables from the core config
43		*/
44	0	private static final StrSubstitutor SUBSTITUTOR = new StrSubstitutor(new ConfigStringLookup());
45
46	0	private Utilities() {
47	0	throw new UnsupportedOperationException("do not call");
48		}
49
50		/**
51		* Performs variable substitution on the specified string, replacing variables specified like ${name}
52		* with the value of the corresponding config parameter obtained from the current context Config object.
53		* This version of the method also takes an application id to qualify the parameter.
54		* @param applicationId the application id to use for qualifying the parameter
55		* @param string the string on which to perform variable substitution
56		* @return a string with any variables substituted with configuration parameter values
57		*/
58		public static String substituteConfigParameters(String applicationId, String string) {
59	0	StrSubstitutor sub = new StrSubstitutor(new ConfigStringLookup(applicationId));
60	0	return sub.replace(string);
61		}
62
63		/**
64		* Performs variable substitution on the specified string, replacing variables specified like ${name}
65		* with the value of the corresponding config parameter obtained from the current context Config object
66		* @param string the string on which to perform variable substitution
67		* @return a string with any variables substituted with configuration parameter values
68		*/
69		public static String substituteConfigParameters(String string) {
70	0	return SUBSTITUTOR.replace(string);
71		}
72
73		public static String parseGroupNamespaceCode(String namespaceAndNameCombo) {
74	0	if (namespaceAndNameCombo == null) {
75	0	return null;
76		}
77	0	String[] groupData = namespaceAndNameCombo.split(KewApiConstants.KIM_GROUP_NAMESPACE_NAME_DELIMITER_CHARACTER);
78	0	if (groupData.length == 1) {
79	0	return KimConstants.KIM_GROUP_WORKFLOW_NAMESPACE_CODE;
80	0	} else if (groupData.length == 2) {
81	0	return groupData[0].trim();
82		} else {
83	0	return null;
84		}
85		}
86
87		public static String parseGroupName(String namespaceAndNameCombo) {
88	0	if (namespaceAndNameCombo == null) {
89	0	return null;
90		}
91	0	String[] groupData = namespaceAndNameCombo.split(KewApiConstants.KIM_GROUP_NAMESPACE_NAME_DELIMITER_CHARACTER);
92	0	if (groupData.length == 1) {
93	0	return groupData[0].trim();
94	0	} else if (groupData.length == 2) {
95	0	return groupData[1].trim();
96		} else {
97	0	return null;
98		}
99		}
100
101		/**
102		*
103		* Consider moving out of this class if this bugs
104		*/
105	0	public static class PrioritySorter implements Comparator<ActionRequestValue> {
106		@Override
107		public int compare(ActionRequestValue ar1, ActionRequestValue ar2) {
108	0	int value = ar1.getPriority().compareTo(ar2.getPriority());
109	0	if (value == 0) {
110	0	value = ActionRequestValue.compareActionCode(ar1.getActionRequested(), ar2.getActionRequested(), true);
111	0	if (value == 0) {
112	0	if ( (ar1.getActionRequestId() != null) && (ar2.getActionRequestId() != null) ) {
113	0	value = ar1.getActionRequestId().compareTo(ar2.getActionRequestId());
114		} else {
115		// if even one action request id is null at this point return that the two are equal
116	0	value = 0;
117		}
118		}
119		}
120	0	return value;
121		}
122		}
123
124		/**
125		*
126		* Consider moving out of this class if this bugs
127		*/
128	0	public static class RouteLogActionRequestSorter extends PrioritySorter implements Comparator<ActionRequestValue> {
129		@Override
130		public int compare(ActionRequestValue ar1, ActionRequestValue ar2) {
131	0	if (! ar1.getChildrenRequests().isEmpty()) {
132	0	Collections.sort(ar1.getChildrenRequests(), this);
133		}
134	0	if (! ar2.getChildrenRequests().isEmpty()) {
135	0	Collections.sort(ar2.getChildrenRequests(), this);
136		}
137
138	0	int routeLevelCompareVal = ar1.getRouteLevel().compareTo(ar2.getRouteLevel());
139	0	if (routeLevelCompareVal != 0) {
140	0	return routeLevelCompareVal;
141		}
142
143	0	if (ar1.isActive() && ar2.isPending()) {
144	0	return -1;
145	0	} else if (ar2.isActive() && ar1.isPending()) {
146	0	return 1;
147		}
148
149	0	return super.compare(ar1, ar2);
150		}
151		}
152
153		public static boolean checkDateRanges(String fromDate, String toDate) {
154		try {
155	0	Date parsedDate = CoreApiServiceLocator.getDateTimeService().convertToDate(fromDate.trim());
156	0	Calendar fromCalendar = Calendar.getInstance();
157	0	fromCalendar.setLenient(false);
158	0	fromCalendar.setTime(parsedDate);
159	0	fromCalendar.set(Calendar.HOUR_OF_DAY, 0);
160	0	fromCalendar.set(Calendar.MINUTE, 0);
161	0	fromCalendar.set(Calendar.SECOND, 0);
162	0	fromCalendar.set(Calendar.MILLISECOND, 0);
163	0	parsedDate = CoreApiServiceLocator.getDateTimeService().convertToDate(toDate.trim());
164	0	Calendar toCalendar = Calendar.getInstance();
165	0	toCalendar.setLenient(false);
166	0	toCalendar.setTime(parsedDate);
167	0	toCalendar.set(Calendar.HOUR_OF_DAY, 0);
168	0	toCalendar.set(Calendar.MINUTE, 0);
169	0	toCalendar.set(Calendar.SECOND, 0);
170	0	toCalendar.set(Calendar.MILLISECOND, 0);
171	0	if (fromCalendar.after(toCalendar)) {
172	0	return false;
173		}
174	0	return true;
175	0	} catch (Exception ex) {
176	0	return false;
177		}
178		}
179
180		/**
181		* Helper method that takes a List of {@link KeyValue} and presents it as a Map
182		* @param collection collection of {@link KeyValue}
183		* @return a Map<String, String> representing the keys and values in the KeyValue collection
184		*/
185		public static <T extends KeyValue> Map<String, String> getKeyValueCollectionAsMap(List<T> collection) {
186	0	Map<String, String> map = new HashMap<String, String>(collection.size());
187	0	for (KeyValue kv: collection) {
188	0	map.put(kv.getKey(), kv.getValue());
189		}
190	0	return map;
191		}
192
193		/**
194		* Helper method that takes a List of {@link KeyValue} and presents it as a Map containing
195		* KeyValue values
196		* @param <T> the key type
197		* @param collection collection of {@link KeyValue}
198		* @return a Map<T,Z> where keys of the KeyValues in the collection are mapped to their respective KeyValue object
199		*/
200		public static <T extends KeyValue> Map<String, T> getKeyValueCollectionAsLookupTable(List<T> collection) {
201	0	Map<String, T> map = new HashMap<String, T>(collection.size());
202	0	for (T kv: collection) {
203	0	map.put(kv.getKey(), kv);
204		}
205	0	return map;
206		}
207		}