Coverage Report

Coverage Report - org.kuali.rice.kns.uif.util.ComponentUtils

Classes in this File

Line Coverage

Branch Coverage

Complexity

ComponentUtils

0/226

0/182

4.379

 /*
  * Copyright 2007 The Kuali Foundation Licensed under the Educational Community
  * License, Version 1.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/ecl1.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.kns.uif.util;
 
 import org.apache.commons.lang.StringUtils;
 import org.kuali.rice.core.util.type.TypeUtils;
 import org.kuali.rice.kns.uif.UifConstants;
 import org.kuali.rice.kns.uif.container.Container;
 import org.kuali.rice.kns.uif.core.Component;
 import org.kuali.rice.kns.uif.core.DataBinding;
 import org.kuali.rice.kns.uif.core.Ordered;
 import org.kuali.rice.kns.uif.field.AttributeField;
 import org.kuali.rice.kns.uif.field.Field;
 import org.kuali.rice.kns.uif.field.GroupField;
 import org.kuali.rice.kns.uif.layout.LayoutManager;
 import org.kuali.rice.kns.util.ObjectUtils;
 import org.springframework.beans.BeanUtils;
 import org.springframework.core.OrderComparator;
 
 import java.beans.PropertyDescriptor;
 import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 /**
  * Utility class providing methods to help create and modify
  * <code>Component</code> instances
  * 
  * @author Kuali Rice Team (rice.collab@kuali.org)
  */
 public class ComponentUtils {
 
     public static <T extends Component> T copy(T component) {
         return copy(component, null);
     }
 
     public static <T extends Component> T copy(T component, String idSuffix) {
         T copy = copyObject(component);
 
         if (StringUtils.isNotBlank(idSuffix)) {
             updateIdsWithSuffixNested(copy, idSuffix);
         }
 
         return copy;
     }
 
     public static <T extends Object> T copyObject(T object) {
         if (object == null) {
             return null;
         }
 
         T copy = null;
         try {
             copy = CloneUtils.deepClone(object);
         }
         catch (Exception e) {
             throw new RuntimeException(e);
         }
 
         return copy;
     }
 
     protected static Object getCopyPropertyValue(Set<String> propertiesForReferenceCopy, String propertyName,
             Object propertyValue) {
         if (propertyValue == null) {
             return null;
         }
 
         Object copyValue = propertyValue;
 
         Class<?> valuePropertyType = propertyValue.getClass();
         if (propertiesForReferenceCopy.contains(propertyName) || TypeUtils.isSimpleType(valuePropertyType)
                 || TypeUtils.isClassClass(valuePropertyType)) {
             return copyValue;
         }
 
         if (Component.class.isAssignableFrom(valuePropertyType)
                 || LayoutManager.class.isAssignableFrom(valuePropertyType)) {
             copyValue = copyObject(propertyValue);
         }
         else {
             copyValue = ObjectUtils.deepCopy((Serializable) propertyValue);
         }
 
         return copyValue;
     }
 
     @SuppressWarnings("unchecked")
     protected static <T extends Object> T getNewInstance(T object) {
         T copy = null;
         try {
             copy = (T) object.getClass().newInstance();
         }
         catch (Exception e) {
             throw new RuntimeException("Unable to create new instance of class: " + object.getClass());
         }
 
         return copy;
     }
 
     public static <T extends Field> List<T> copyFieldList(List<T> fields, String addBindingPrefix, String idSuffix) {
         List<T> copiedFieldList = copyFieldList(fields, idSuffix);
 
         prefixBindingPath(copiedFieldList, addBindingPrefix);
 
         return copiedFieldList;
     }
 
     public static <T extends Field> List<T> copyFieldList(List<T> fields, String idSuffix) {
         List<T> copiedFieldList = new ArrayList<T>();
 
         for (T field : fields) {
             T copiedField = copy(field, idSuffix);
             copiedFieldList.add(copiedField);
         }
 
         return copiedFieldList;
     }
 
     public static <T extends Component> T copyComponent(T component, String addBindingPrefix, String idSuffix) {
         T copy = copy(component, idSuffix);
 
         prefixBindingPathNested(component, addBindingPrefix);
 
         return copy;
     }
 
     public static <T extends Component> List<T> copyComponentList(List<T> components, String idSuffix) {
         List<T> copiedComponentList = new ArrayList<T>();
 
         for (T field : components) {
             T copiedComponent = copy(field, idSuffix);
             copiedComponentList.add(copiedComponent);
         }
 
         return copiedComponentList;
     }
 
     @SuppressWarnings("unchecked")
     public static <T extends Component> List<T> getComponentsOfType(List<? extends Component> items,
             Class<T> componentType) {
         List<T> typeComponents = new ArrayList<T>();
 
         for (Component component : items) {
             if (componentType.isAssignableFrom(component.getClass())) {
                 typeComponents.add((T) component);
             }
         }
 
         return typeComponents;
     }
     
     public static <T extends Component> List<T> getComponentsOfTypeDeep(List<? extends Component> items,
             Class<T> componentType) {
         List<T> typeComponents = new ArrayList<T>();
 
         for (Component component : items) {
             typeComponents.addAll(getComponentsOfTypeDeep(component, componentType));
         }
 
         return typeComponents;
     }
     
     @SuppressWarnings("unchecked")
     public static <T extends Component> List<T> getComponentsOfTypeDeep(Component component, Class<T> componentType) {
         List<T> typeComponents = new ArrayList<T>();
 
         if (component == null) {
             return typeComponents;
         }
 
         if (componentType.isAssignableFrom(component.getClass())) {
             typeComponents.add((T) component);
         }
 
         for (Component nested : component.getNestedComponents()) {
             typeComponents.addAll(getComponentsOfTypeDeep(nested, componentType));
         }
 
         return typeComponents;
     }   
 
     public static void prefixBindingPath(List<? extends Field> fields, String addBindingPrefix) {
         for (Field field : fields) {
             if (field instanceof DataBinding) {
                 prefixBindingPath((DataBinding) field, addBindingPrefix);
             }
             else if (field instanceof GroupField) {
                 List<Field> groupFields = getComponentsOfType(((GroupField) field).getItems(), Field.class);
                 prefixBindingPath(groupFields, addBindingPrefix);
             }
         }
     }
 
     public static void prefixBindingPathNested(Component component, String addBindingPrefix) {
         if (component instanceof DataBinding) {
             prefixBindingPath((DataBinding) component, addBindingPrefix);
         }
 
         for (Component nested : component.getNestedComponents()) {
            if (nested != null) {
               prefixBindingPathNested(nested, addBindingPrefix);
            }
         }
     }
 
     public static void prefixBindingPath(DataBinding field, String addBindingPrefix) {
         String bindingPrefix = addBindingPrefix;
         if (StringUtils.isNotBlank(field.getBindingInfo().getBindByNamePrefix())) {
             bindingPrefix += "." + field.getBindingInfo().getBindByNamePrefix();
         }
         field.getBindingInfo().setBindByNamePrefix(bindingPrefix);
         
         if (field instanceof AttributeField){
                 AttributeField attrfield = (AttributeField)field;
                 if (StringUtils.isNotBlank(attrfield.getAdditionalDisplayPropertyName())){
                         attrfield.getAdditionalDisplayPropertyBindingInfo().setBindByNamePrefix(bindingPrefix);
                 }
                 if (StringUtils.isNotBlank(attrfield.getAlternateDisplayPropertyName())){
                         attrfield.getAlternateDisplayPropertyBindingInfo().setBindByNamePrefix(bindingPrefix);
                 }
         }
     }
 
     public static void updateIdsWithSuffixNested(List<? extends Component> components, String idSuffix) {
         for (Component component : components) {
             updateIdsWithSuffixNested(component, idSuffix);
         }
     }
 
     public static void updateIdsWithSuffixNested(Component component, String idSuffix) {
         updateIdsWithSuffix(component, idSuffix);
 
         if (Container.class.isAssignableFrom(component.getClass())) {
             LayoutManager layoutManager = ((Container) component).getLayoutManager();
             layoutManager.setId(layoutManager.getId() + idSuffix);
         }
 
         for (Component nested : component.getNestedComponents()) {
             if (nested != null) {
                 updateIdsWithSuffixNested(nested, idSuffix);
             }
         }
     }
 
     public static void updateIdsWithSuffix(Component component, String idSuffix) {
         // make sure id has two underscore delimiter so we can pick off original dictionary id
         component.setId(component.getId() + idSuffix);
     }
 
     public static void setComponentsPropertyDeep(List<? extends Component> components, String propertyPath,
             Object propertyValue) {
         for (Component component : components) {
             setComponentPropertyDeep(component, propertyPath, propertyValue);
         }
     }
 
     public static void setComponentPropertyDeep(Component component, String propertyPath, Object propertyValue) {
         ObjectPropertyUtils.setPropertyValue(component, propertyPath, propertyValue, true);
 
         for (Component nested : component.getNestedComponents()) {
             if (nested != null) {
                 setComponentPropertyDeep(nested, propertyPath, propertyValue);
             }
         }
     }
 
     public static List<String> getComponentPropertyNames(Class<? extends Component> componentClass) {
         List<String> componentProperties = new ArrayList<String>();
 
         PropertyDescriptor[] properties = BeanUtils.getPropertyDescriptors(componentClass);
         for (int i = 0; i < properties.length; i++) {
             PropertyDescriptor descriptor = properties[i];
             if (descriptor.getReadMethod() != null) {
                 componentProperties.add(descriptor.getName());
             }
         }
 
         return componentProperties;
     }
 
     public static void pushObjectToContext(List<? extends Component> components, String contextName, Object contextValue) {
         for (Component component : components) {
             pushObjectToContext(component, contextName, contextValue);
         }
     }
 
     public static void pushObjectToContext(Component component, String contextName, Object contextValue) {
         if (component == null) {
             return;
         }
 
         component.pushObjectToContext(contextName, contextValue);
 
         // special container check so we pick up the layout manager
         if (Container.class.isAssignableFrom(component.getClass())) {
             LayoutManager layoutManager = ((Container) component).getLayoutManager();
             if (layoutManager != null) {
                 layoutManager.pushObjectToContext(contextName, contextValue);
 
                 for (Component nestedComponent : layoutManager.getNestedComponents()) {
                     pushObjectToContext(nestedComponent, contextName, contextValue);
                 }
             }
         }
 
         for (Component nestedComponent : component.getNestedComponents()) {
             pushObjectToContext(nestedComponent, contextName, contextValue);
         }
     }
 
     public static void updateContextsForLine(List<? extends Component> components, Object collectionLine,
             int lineIndex) {
         for (Component component : components) {
             updateContextForLine(component, collectionLine, lineIndex);
         }
     }
 
     public static void updateContextForLine(Component component, Object collectionLine, int lineIndex) {
         pushObjectToContext(component, UifConstants.ContextVariableNames.LINE, collectionLine);
         pushObjectToContext(component, UifConstants.ContextVariableNames.INDEX, new Integer(lineIndex));
         
         boolean isAddLine = (lineIndex == -1);
         pushObjectToContext(component, UifConstants.ContextVariableNames.IS_ADD_LINE, isAddLine);
     }
 
     public static void processIds(Component component, Map<String, Integer> seenIds) {
         String componentId = component.getId();
         Integer seenCount = new Integer(0);
         if (StringUtils.isNotBlank(componentId)) {
             if (seenIds.containsKey(componentId)) {
                 seenCount = seenIds.get(componentId);
                 seenCount += 1;
 
                 component.setId(componentId + "_" + seenCount);
             }
 
             seenIds.put(componentId, seenCount);
         }
 
         if (Container.class.isAssignableFrom(component.getClass())) {
             LayoutManager layoutManager = ((Container) component).getLayoutManager();
             if ((layoutManager != null) && StringUtils.isNotBlank(layoutManager.getId())) {
                 seenCount = new Integer(0);
                 if (seenIds.containsKey(layoutManager.getId())) {
                     seenCount = seenIds.get(layoutManager.getId());
                     seenCount += 1;
 
                     layoutManager.setId(layoutManager.getId() + "_" + seenCount);
                 }
 
                 seenIds.put(layoutManager.getId(), seenCount);
             }
         }
 
         for (Component nested : component.getNestedComponents()) {
             if (nested != null) {
                 processIds(nested, seenIds);
             }
         }
     }
 
     /**
      * Performs sorting logic of the given list of <code>Ordered</code>
      * instances by its order property
      * <p>
      * Items list is sorted based on its order property. Lower order values are
      * placed higher in the list. If a item does not have a value assigned for
      * the order (or is equal to the default order of 0), it will be assigned
      * the a value based on the given order sequence integer. If two or more
      * items share the same order value, all but the last item found in the list
      * will be removed.
      * </p>
      * 
      * @param items
      * @param defaultOrderSequence
      * @return List<Ordered> sorted items
      * @see org.kuali.rice.kns.uif.Component.getOrder()
      * @see @see org.springframework.core.Ordered
      */
     public static List<? extends Ordered> sort(List<? extends Ordered> items, int defaultOrderSequence) {
         List<Ordered> orderedItems = new ArrayList<Ordered>();
 
         // do replacement for items with the same order property value
         Set<Integer> foundOrders = new HashSet<Integer>();
 
         // reverse the list, so items later in the list win
         Collections.reverse(items);
         for (Ordered component : items) {
             int order = component.getOrder();
 
             // if order not set just add to list
             if (order == 0) {
                 orderedItems.add(component);
             }
             // check if the order value has been used already
             else if (!foundOrders.contains(new Integer(order))) {
                 orderedItems.add(component);
                 foundOrders.add(new Integer(order));
             }
         }
 
         // now reverse the list back so we can assign defaults for items without
         // an order value
         Collections.reverse(items);
         for (Ordered component : items) {
             int order = component.getOrder();
 
             // if order property not set assign default
             if (order == 0) {
                 defaultOrderSequence++;
                 while (foundOrders.contains(new Integer(defaultOrderSequence))) {
                     defaultOrderSequence++;
                 }
                 component.setOrder(defaultOrderSequence);
             }
         }
 
         // now sort the list by its order property
         Collections.sort(orderedItems, new OrderComparator());
 
         return orderedItems;
     }
     
     /**
      * This method takes in an expression and a list to be filled in with names(property names)
      * of controls found in the expression. This method returns a js expression which can
      * be executed on the client to determine if the original exp was satisfied before
      * interacting with the server - ie, this js expression is equivalent to the one passed in.
      * 
      * There are limitations on the Spring expression language that can be used as this method.
      * It is only used to parse expressions which are valid case statements for determining if
      * some action/processing should be performed.  ONLY Properties, comparison operators, booleans,
      * strings, matches expression, and boolean logic are supported.  Properties must
      * be a valid property on the form, and should have a visible control within the view.
      * 
      * Example valid exp: account.name == 'Account Name'
      * 
      * @param exp
      * @param controlNames
      * @return
      */
     public static String parseExpression(String exp, List<String> controlNames){
         //Clean up expression to ease parsing
         exp = StringUtils.replace(exp, "!=", " != ");
         exp = StringUtils.replace(exp, "==", " == ");
         exp = StringUtils.replace(exp, ">", " > ");
         exp = StringUtils.replace(exp, "<", " < ");
         exp = StringUtils.replace(exp, "<=", " <= ");
         exp = StringUtils.replace(exp, ">=", " >= ");
         exp = exp.trim();
 
         String conditionJs = exp;
         String stack = "";
         boolean expectingSingleQuote = false;
         boolean ignoreNext = false;
         for(int i = 0; i < exp.length(); i++) { 
             char c = exp.charAt(i);
             if(!expectingSingleQuote && !ignoreNext && (c == '(' || c == ' ' || c == ')')){
                 evaluateCurrentStack(stack.trim(), controlNames);
                 //reset stack
                 stack = "";
                 continue;
             }
             else if(!ignoreNext && c == '\''){
                 stack = stack + c;
                 expectingSingleQuote = !expectingSingleQuote;
             }
             else if(c == '\\'){
                 stack = stack + c;
                 ignoreNext = !ignoreNext;
             }
             else{
                 stack = stack + c;
                 ignoreNext = false;
             }
         }
         
         conditionJs = conditionJs
         .replaceAll("\\s(?i:ne)\\s", " != ")
         .replaceAll("\\s(?i:eq)\\s", " == ")
         .replaceAll("\\s(?i:gt)\\s", " > ")
         .replaceAll("\\s(?i:lt)\\s", " < ")
         .replaceAll("\\s(?i:lte)\\s", " <= ")
         .replaceAll("\\s(?i:gte)\\s", " >= ")
         .replaceAll("\\s(?i:and)\\s", " && ")
         .replaceAll("\\s(?i:or)\\s", " || ")
         .replaceAll("\\s+(?i:matches)\\s+'.*'", ".match(/" 
                 + "$0".replaceAll("\\s+(?i:matches)\\s+", "") + "/).length > 0 ");
         
         for(String propertyName: controlNames){
             conditionJs = conditionJs.replace(propertyName, 
                     "coerceValue(\""+ propertyName +"\")");
         }
         return conditionJs;
     }
     
     /**
      * Used internally by parseExpression to evalute if the current stack is a property
      * name (ie, will be a control on the form)
      * 
      * @param stack
      * @param controlNames
      */
     private static void evaluateCurrentStack(String stack, List<String> controlNames){
        if(StringUtils.isNotBlank(stack)){
            if(!(stack.equals("==") 
                    || stack.equals("!=")
                    || stack.equals(">")
                    || stack.equals("<")
                    || stack.equals(">=")
                    || stack.equals("<=")
                    || stack.equalsIgnoreCase("ne")
                    || stack.equalsIgnoreCase("eq")
                    || stack.equalsIgnoreCase("gt")
                    || stack.equalsIgnoreCase("lt")
                    || stack.equalsIgnoreCase("lte")
                    || stack.equalsIgnoreCase("gte")
                    || stack.equalsIgnoreCase("matches"))){
                
                boolean isNumber = false;
                if((StringUtils.isNumeric(stack.substring(0,1)) 
                        || stack.substring(0,1).equals("-"))){
                    try{
                        Double.parseDouble(stack);
                        isNumber = true;
                    }
                    catch(NumberFormatException e){
                        isNumber = false;
                    }
                }
                
                if(!(stack.equalsIgnoreCase("false") || stack.equalsIgnoreCase("true") || isNumber
                        || stack.startsWith("'") || stack.endsWith("'"))){
                    if(!controlNames.contains(stack)){
                        controlNames.add(stack);
                    }
                }
            }
        }
     }
 
 }

1		/*
2		* Copyright 2007 The Kuali Foundation Licensed under the Educational Community
3		* License, Version 1.0 (the "License"); you may not use this file except in
4		* compliance with the License. You may obtain a copy of the License at
5		* http://www.opensource.org/licenses/ecl1.php Unless required by applicable law
6		* or agreed to in writing, software distributed under the License is
7		* distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
8		* KIND, either express or implied. See the License for the specific language
9		* governing permissions and limitations under the License.
10		*/
11		package org.kuali.rice.kns.uif.util;
12
13		import org.apache.commons.lang.StringUtils;
14		import org.kuali.rice.core.util.type.TypeUtils;
15		import org.kuali.rice.kns.uif.UifConstants;
16		import org.kuali.rice.kns.uif.container.Container;
17		import org.kuali.rice.kns.uif.core.Component;
18		import org.kuali.rice.kns.uif.core.DataBinding;
19		import org.kuali.rice.kns.uif.core.Ordered;
20		import org.kuali.rice.kns.uif.field.AttributeField;
21		import org.kuali.rice.kns.uif.field.Field;
22		import org.kuali.rice.kns.uif.field.GroupField;
23		import org.kuali.rice.kns.uif.layout.LayoutManager;
24		import org.kuali.rice.kns.util.ObjectUtils;
25		import org.springframework.beans.BeanUtils;
26		import org.springframework.core.OrderComparator;
27
28		import java.beans.PropertyDescriptor;
29		import java.io.Serializable;
30		import java.util.ArrayList;
31		import java.util.Collections;
32		import java.util.HashSet;
33		import java.util.List;
34		import java.util.Map;
35		import java.util.Set;
36
37		/**
38		* Utility class providing methods to help create and modify
39		* <code>Component</code> instances
40		*
41		* @author Kuali Rice Team (rice.collab@kuali.org)
42		*/
43	0	public class ComponentUtils {
44
45		public static <T extends Component> T copy(T component) {
46	0	return copy(component, null);
47		}
48
49		public static <T extends Component> T copy(T component, String idSuffix) {
50	0	T copy = copyObject(component);
51
52	0	if (StringUtils.isNotBlank(idSuffix)) {
53	0	updateIdsWithSuffixNested(copy, idSuffix);
54		}
55
56	0	return copy;
57		}
58
59		public static <T extends Object> T copyObject(T object) {
60	0	if (object == null) {
61	0	return null;
62		}
63
64	0	T copy = null;
65		try {
66	0	copy = CloneUtils.deepClone(object);
67		}
68	0	catch (Exception e) {
69	0	throw new RuntimeException(e);
70	0	}
71
72	0	return copy;
73		}
74
75		protected static Object getCopyPropertyValue(Set<String> propertiesForReferenceCopy, String propertyName,
76		Object propertyValue) {
77	0	if (propertyValue == null) {
78	0	return null;
79		}
80
81	0	Object copyValue = propertyValue;
82
83	0	Class<?> valuePropertyType = propertyValue.getClass();
84	0	if (propertiesForReferenceCopy.contains(propertyName) \|\| TypeUtils.isSimpleType(valuePropertyType)
85		\|\| TypeUtils.isClassClass(valuePropertyType)) {
86	0	return copyValue;
87		}
88
89	0	if (Component.class.isAssignableFrom(valuePropertyType)
90		\|\| LayoutManager.class.isAssignableFrom(valuePropertyType)) {
91	0	copyValue = copyObject(propertyValue);
92		}
93		else {
94	0	copyValue = ObjectUtils.deepCopy((Serializable) propertyValue);
95		}
96
97	0	return copyValue;
98		}
99
100		@SuppressWarnings("unchecked")
101		protected static <T extends Object> T getNewInstance(T object) {
102	0	T copy = null;
103		try {
104	0	copy = (T) object.getClass().newInstance();
105		}
106	0	catch (Exception e) {
107	0	throw new RuntimeException("Unable to create new instance of class: " + object.getClass());
108	0	}
109
110	0	return copy;
111		}
112
113		public static <T extends Field> List<T> copyFieldList(List<T> fields, String addBindingPrefix, String idSuffix) {
114	0	List<T> copiedFieldList = copyFieldList(fields, idSuffix);
115
116	0	prefixBindingPath(copiedFieldList, addBindingPrefix);
117
118	0	return copiedFieldList;
119		}
120
121		public static <T extends Field> List<T> copyFieldList(List<T> fields, String idSuffix) {
122	0	List<T> copiedFieldList = new ArrayList<T>();
123
124	0	for (T field : fields) {
125	0	T copiedField = copy(field, idSuffix);
126	0	copiedFieldList.add(copiedField);
127	0	}
128
129	0	return copiedFieldList;
130		}
131
132		public static <T extends Component> T copyComponent(T component, String addBindingPrefix, String idSuffix) {
133	0	T copy = copy(component, idSuffix);
134
135	0	prefixBindingPathNested(component, addBindingPrefix);
136
137	0	return copy;
138		}
139
140		public static <T extends Component> List<T> copyComponentList(List<T> components, String idSuffix) {
141	0	List<T> copiedComponentList = new ArrayList<T>();
142
143	0	for (T field : components) {
144	0	T copiedComponent = copy(field, idSuffix);
145	0	copiedComponentList.add(copiedComponent);
146	0	}
147
148	0	return copiedComponentList;
149		}
150
151		@SuppressWarnings("unchecked")
152		public static <T extends Component> List<T> getComponentsOfType(List<? extends Component> items,
153		Class<T> componentType) {
154	0	List<T> typeComponents = new ArrayList<T>();
155
156	0	for (Component component : items) {
157	0	if (componentType.isAssignableFrom(component.getClass())) {
158	0	typeComponents.add((T) component);
159		}
160		}
161
162	0	return typeComponents;
163		}
164
165		public static <T extends Component> List<T> getComponentsOfTypeDeep(List<? extends Component> items,
166		Class<T> componentType) {
167	0	List<T> typeComponents = new ArrayList<T>();
168
169	0	for (Component component : items) {
170	0	typeComponents.addAll(getComponentsOfTypeDeep(component, componentType));
171		}
172
173	0	return typeComponents;
174		}
175
176		@SuppressWarnings("unchecked")
177		public static <T extends Component> List<T> getComponentsOfTypeDeep(Component component, Class<T> componentType) {
178	0	List<T> typeComponents = new ArrayList<T>();
179
180	0	if (component == null) {
181	0	return typeComponents;
182		}
183
184	0	if (componentType.isAssignableFrom(component.getClass())) {
185	0	typeComponents.add((T) component);
186		}
187
188	0	for (Component nested : component.getNestedComponents()) {
189	0	typeComponents.addAll(getComponentsOfTypeDeep(nested, componentType));
190		}
191
192	0	return typeComponents;
193		}
194
195		public static void prefixBindingPath(List<? extends Field> fields, String addBindingPrefix) {
196	0	for (Field field : fields) {
197	0	if (field instanceof DataBinding) {
198	0	prefixBindingPath((DataBinding) field, addBindingPrefix);
199		}
200	0	else if (field instanceof GroupField) {
201	0	List<Field> groupFields = getComponentsOfType(((GroupField) field).getItems(), Field.class);
202	0	prefixBindingPath(groupFields, addBindingPrefix);
203	0	}
204		}
205	0	}
206
207		public static void prefixBindingPathNested(Component component, String addBindingPrefix) {
208	0	if (component instanceof DataBinding) {
209	0	prefixBindingPath((DataBinding) component, addBindingPrefix);
210		}
211
212	0	for (Component nested : component.getNestedComponents()) {
213	0	if (nested != null) {
214	0	prefixBindingPathNested(nested, addBindingPrefix);
215		}
216		}
217	0	}
218
219		public static void prefixBindingPath(DataBinding field, String addBindingPrefix) {
220	0	String bindingPrefix = addBindingPrefix;
221	0	if (StringUtils.isNotBlank(field.getBindingInfo().getBindByNamePrefix())) {
222	0	bindingPrefix += "." + field.getBindingInfo().getBindByNamePrefix();
223		}
224	0	field.getBindingInfo().setBindByNamePrefix(bindingPrefix);
225
226	0	if (field instanceof AttributeField){
227	0	AttributeField attrfield = (AttributeField)field;
228	0	if (StringUtils.isNotBlank(attrfield.getAdditionalDisplayPropertyName())){
229	0	attrfield.getAdditionalDisplayPropertyBindingInfo().setBindByNamePrefix(bindingPrefix);
230		}
231	0	if (StringUtils.isNotBlank(attrfield.getAlternateDisplayPropertyName())){
232	0	attrfield.getAlternateDisplayPropertyBindingInfo().setBindByNamePrefix(bindingPrefix);
233		}
234		}
235	0	}
236
237		public static void updateIdsWithSuffixNested(List<? extends Component> components, String idSuffix) {
238	0	for (Component component : components) {
239	0	updateIdsWithSuffixNested(component, idSuffix);
240		}
241	0	}
242
243		public static void updateIdsWithSuffixNested(Component component, String idSuffix) {
244	0	updateIdsWithSuffix(component, idSuffix);
245
246	0	if (Container.class.isAssignableFrom(component.getClass())) {
247	0	LayoutManager layoutManager = ((Container) component).getLayoutManager();
248	0	layoutManager.setId(layoutManager.getId() + idSuffix);
249		}
250
251	0	for (Component nested : component.getNestedComponents()) {
252	0	if (nested != null) {
253	0	updateIdsWithSuffixNested(nested, idSuffix);
254		}
255		}
256	0	}
257
258		public static void updateIdsWithSuffix(Component component, String idSuffix) {
259		// make sure id has two underscore delimiter so we can pick off original dictionary id
260	0	component.setId(component.getId() + idSuffix);
261	0	}
262
263		public static void setComponentsPropertyDeep(List<? extends Component> components, String propertyPath,
264		Object propertyValue) {
265	0	for (Component component : components) {
266	0	setComponentPropertyDeep(component, propertyPath, propertyValue);
267		}
268	0	}
269
270		public static void setComponentPropertyDeep(Component component, String propertyPath, Object propertyValue) {
271	0	ObjectPropertyUtils.setPropertyValue(component, propertyPath, propertyValue, true);
272
273	0	for (Component nested : component.getNestedComponents()) {
274	0	if (nested != null) {
275	0	setComponentPropertyDeep(nested, propertyPath, propertyValue);
276		}
277		}
278	0	}
279
280		public static List<String> getComponentPropertyNames(Class<? extends Component> componentClass) {
281	0	List<String> componentProperties = new ArrayList<String>();
282
283	0	PropertyDescriptor[] properties = BeanUtils.getPropertyDescriptors(componentClass);
284	0	for (int i = 0; i < properties.length; i++) {
285	0	PropertyDescriptor descriptor = properties[i];
286	0	if (descriptor.getReadMethod() != null) {
287	0	componentProperties.add(descriptor.getName());
288		}
289		}
290
291	0	return componentProperties;
292		}
293
294		public static void pushObjectToContext(List<? extends Component> components, String contextName, Object contextValue) {
295	0	for (Component component : components) {
296	0	pushObjectToContext(component, contextName, contextValue);
297		}
298	0	}
299
300		public static void pushObjectToContext(Component component, String contextName, Object contextValue) {
301	0	if (component == null) {
302	0	return;
303		}
304
305	0	component.pushObjectToContext(contextName, contextValue);
306
307		// special container check so we pick up the layout manager
308	0	if (Container.class.isAssignableFrom(component.getClass())) {
309	0	LayoutManager layoutManager = ((Container) component).getLayoutManager();
310	0	if (layoutManager != null) {
311	0	layoutManager.pushObjectToContext(contextName, contextValue);
312
313	0	for (Component nestedComponent : layoutManager.getNestedComponents()) {
314	0	pushObjectToContext(nestedComponent, contextName, contextValue);
315		}
316		}
317		}
318
319	0	for (Component nestedComponent : component.getNestedComponents()) {
320	0	pushObjectToContext(nestedComponent, contextName, contextValue);
321		}
322	0	}
323
324		public static void updateContextsForLine(List<? extends Component> components, Object collectionLine,
325		int lineIndex) {
326	0	for (Component component : components) {
327	0	updateContextForLine(component, collectionLine, lineIndex);
328		}
329	0	}
330
331		public static void updateContextForLine(Component component, Object collectionLine, int lineIndex) {
332	0	pushObjectToContext(component, UifConstants.ContextVariableNames.LINE, collectionLine);
333	0	pushObjectToContext(component, UifConstants.ContextVariableNames.INDEX, new Integer(lineIndex));
334
335	0	boolean isAddLine = (lineIndex == -1);
336	0	pushObjectToContext(component, UifConstants.ContextVariableNames.IS_ADD_LINE, isAddLine);
337	0	}
338
339		public static void processIds(Component component, Map<String, Integer> seenIds) {
340	0	String componentId = component.getId();
341	0	Integer seenCount = new Integer(0);
342	0	if (StringUtils.isNotBlank(componentId)) {
343	0	if (seenIds.containsKey(componentId)) {
344	0	seenCount = seenIds.get(componentId);
345	0	seenCount += 1;
346
347	0	component.setId(componentId + "_" + seenCount);
348		}
349
350	0	seenIds.put(componentId, seenCount);
351		}
352
353	0	if (Container.class.isAssignableFrom(component.getClass())) {
354	0	LayoutManager layoutManager = ((Container) component).getLayoutManager();
355	0	if ((layoutManager != null) && StringUtils.isNotBlank(layoutManager.getId())) {
356	0	seenCount = new Integer(0);
357	0	if (seenIds.containsKey(layoutManager.getId())) {
358	0	seenCount = seenIds.get(layoutManager.getId());
359	0	seenCount += 1;
360
361	0	layoutManager.setId(layoutManager.getId() + "_" + seenCount);
362		}
363
364	0	seenIds.put(layoutManager.getId(), seenCount);
365		}
366		}
367
368	0	for (Component nested : component.getNestedComponents()) {
369	0	if (nested != null) {
370	0	processIds(nested, seenIds);
371		}
372		}
373	0	}
374
375		/**
376		* Performs sorting logic of the given list of <code>Ordered</code>
377		* instances by its order property
378		* <p>
379		* Items list is sorted based on its order property. Lower order values are
380		* placed higher in the list. If a item does not have a value assigned for
381		* the order (or is equal to the default order of 0), it will be assigned
382		* the a value based on the given order sequence integer. If two or more
383		* items share the same order value, all but the last item found in the list
384		* will be removed.
385		* </p>
386		*
387		* @param items
388		* @param defaultOrderSequence
389		* @return List<Ordered> sorted items
390		* @see org.kuali.rice.kns.uif.Component.getOrder()
391		* @see @see org.springframework.core.Ordered
392		*/
393		public static List<? extends Ordered> sort(List<? extends Ordered> items, int defaultOrderSequence) {
394	0	List<Ordered> orderedItems = new ArrayList<Ordered>();
395
396		// do replacement for items with the same order property value
397	0	Set<Integer> foundOrders = new HashSet<Integer>();
398
399		// reverse the list, so items later in the list win
400	0	Collections.reverse(items);
401	0	for (Ordered component : items) {
402	0	int order = component.getOrder();
403
404		// if order not set just add to list
405	0	if (order == 0) {
406	0	orderedItems.add(component);
407		}
408		// check if the order value has been used already
409	0	else if (!foundOrders.contains(new Integer(order))) {
410	0	orderedItems.add(component);
411	0	foundOrders.add(new Integer(order));
412		}
413	0	}
414
415		// now reverse the list back so we can assign defaults for items without
416		// an order value
417	0	Collections.reverse(items);
418	0	for (Ordered component : items) {
419	0	int order = component.getOrder();
420
421		// if order property not set assign default
422	0	if (order == 0) {
423	0	defaultOrderSequence++;
424	0	while (foundOrders.contains(new Integer(defaultOrderSequence))) {
425	0	defaultOrderSequence++;
426		}
427	0	component.setOrder(defaultOrderSequence);
428		}
429	0	}
430
431		// now sort the list by its order property
432	0	Collections.sort(orderedItems, new OrderComparator());
433
434	0	return orderedItems;
435		}
436
437		/**
438		* This method takes in an expression and a list to be filled in with names(property names)
439		* of controls found in the expression. This method returns a js expression which can
440		* be executed on the client to determine if the original exp was satisfied before
441		* interacting with the server - ie, this js expression is equivalent to the one passed in.
442		*
443		* There are limitations on the Spring expression language that can be used as this method.
444		* It is only used to parse expressions which are valid case statements for determining if
445		* some action/processing should be performed. ONLY Properties, comparison operators, booleans,
446		* strings, matches expression, and boolean logic are supported. Properties must
447		* be a valid property on the form, and should have a visible control within the view.
448		*
449		* Example valid exp: account.name == 'Account Name'
450		*
451		* @param exp
452		* @param controlNames
453		* @return
454		*/
455		public static String parseExpression(String exp, List<String> controlNames){
456		//Clean up expression to ease parsing
457	0	exp = StringUtils.replace(exp, "!=", " != ");
458	0	exp = StringUtils.replace(exp, "==", " == ");
459	0	exp = StringUtils.replace(exp, ">", " > ");
460	0	exp = StringUtils.replace(exp, "<", " < ");
461	0	exp = StringUtils.replace(exp, "<=", " <= ");
462	0	exp = StringUtils.replace(exp, ">=", " >= ");
463	0	exp = exp.trim();
464
465	0	String conditionJs = exp;
466	0	String stack = "";
467	0	boolean expectingSingleQuote = false;
468	0	boolean ignoreNext = false;
469	0	for(int i = 0; i < exp.length(); i++) {
470	0	char c = exp.charAt(i);
471	0	if(!expectingSingleQuote && !ignoreNext && (c == '(' \|\| c == ' ' \|\| c == ')')){
472	0	evaluateCurrentStack(stack.trim(), controlNames);
473		//reset stack
474	0	stack = "";
475	0	continue;
476		}
477	0	else if(!ignoreNext && c == '\''){
478	0	stack = stack + c;
479	0	expectingSingleQuote = !expectingSingleQuote;
480		}
481	0	else if(c == '\\'){
482	0	stack = stack + c;
483	0	ignoreNext = !ignoreNext;
484		}
485		else{
486	0	stack = stack + c;
487	0	ignoreNext = false;
488		}
489		}
490
491	0	conditionJs = conditionJs
492		.replaceAll("\\s(?i:ne)\\s", " != ")
493		.replaceAll("\\s(?i:eq)\\s", " == ")
494		.replaceAll("\\s(?i:gt)\\s", " > ")
495		.replaceAll("\\s(?i:lt)\\s", " < ")
496		.replaceAll("\\s(?i:lte)\\s", " <= ")
497		.replaceAll("\\s(?i:gte)\\s", " >= ")
498		.replaceAll("\\s(?i:and)\\s", " && ")
499		.replaceAll("\\s(?i:or)\\s", " \|\| ")
500		.replaceAll("\\s+(?i:matches)\\s+'.*'", ".match(/"
501		+ "$0".replaceAll("\\s+(?i:matches)\\s+", "") + "/).length > 0 ");
502
503	0	for(String propertyName: controlNames){
504	0	conditionJs = conditionJs.replace(propertyName,
505		"coerceValue(\""+ propertyName +"\")");
506		}
507	0	return conditionJs;
508		}
509
510		/**
511		* Used internally by parseExpression to evalute if the current stack is a property
512		* name (ie, will be a control on the form)
513		*
514		* @param stack
515		* @param controlNames
516		*/
517		private static void evaluateCurrentStack(String stack, List<String> controlNames){
518	0	if(StringUtils.isNotBlank(stack)){
519	0	if(!(stack.equals("==")
520		\|\| stack.equals("!=")
521		\|\| stack.equals(">")
522		\|\| stack.equals("<")
523		\|\| stack.equals(">=")
524		\|\| stack.equals("<=")
525		\|\| stack.equalsIgnoreCase("ne")
526		\|\| stack.equalsIgnoreCase("eq")
527		\|\| stack.equalsIgnoreCase("gt")
528		\|\| stack.equalsIgnoreCase("lt")
529		\|\| stack.equalsIgnoreCase("lte")
530		\|\| stack.equalsIgnoreCase("gte")
531		\|\| stack.equalsIgnoreCase("matches"))){
532
533	0	boolean isNumber = false;
534	0	if((StringUtils.isNumeric(stack.substring(0,1))
535		\|\| stack.substring(0,1).equals("-"))){
536		try{
537	0	Double.parseDouble(stack);
538	0	isNumber = true;
539		}
540	0	catch(NumberFormatException e){
541	0	isNumber = false;
542	0	}
543		}
544
545	0	if(!(stack.equalsIgnoreCase("false") \|\| stack.equalsIgnoreCase("true") \|\| isNumber
546		\|\| stack.startsWith("'") \|\| stack.endsWith("'"))){
547	0	if(!controlNames.contains(stack)){
548	0	controlNames.add(stack);
549		}
550		}
551		}
552		}
553	0	}
554
555		}