1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.kuali.rice.krad.uif.view;
17
18 import java.lang.reflect.Method;
19 import java.util.ArrayList;
20 import java.util.Collection;
21 import java.util.HashMap;
22 import java.util.List;
23 import java.util.Map;
24 import java.util.regex.Matcher;
25 import java.util.regex.Pattern;
26
27 import org.apache.commons.lang.StringUtils;
28 import org.apache.commons.lang.math.NumberUtils;
29 import org.kuali.rice.core.api.exception.RiceRuntimeException;
30 import org.kuali.rice.krad.datadictionary.uif.UifDictionaryBean;
31 import org.kuali.rice.krad.uif.UifConstants;
32 import org.kuali.rice.krad.uif.component.BindingInfo;
33 import org.kuali.rice.krad.uif.component.Component;
34 import org.kuali.rice.krad.uif.component.KeepExpression;
35 import org.kuali.rice.krad.uif.component.PropertyReplacer;
36 import org.kuali.rice.krad.uif.container.CollectionGroup;
37 import org.kuali.rice.krad.uif.field.DataField;
38 import org.kuali.rice.krad.uif.layout.LayoutManager;
39 import org.kuali.rice.krad.uif.util.CopyUtils;
40 import org.kuali.rice.krad.uif.util.ExpressionFunctions;
41 import org.kuali.rice.krad.uif.util.ObjectPropertyUtils;
42 import org.springframework.expression.Expression;
43 import org.springframework.expression.ExpressionParser;
44 import org.springframework.expression.common.TemplateParserContext;
45 import org.springframework.expression.spel.standard.SpelExpressionParser;
46 import org.springframework.expression.spel.support.StandardEvaluationContext;
47
48
49
50
51
52
53 public class DefaultExpressionEvaluator implements ExpressionEvaluator {
54 private static final org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(
55 DefaultExpressionEvaluator.class);
56
57 protected static final Pattern SERVER_EVALUATION_PATTERN = Pattern.compile(
58 "(\\s?!?\\b(#|get|is)(.*?\\(.*?\\)))(\\s|$)");
59
60 private StandardEvaluationContext evaluationContext;
61
62 private Map<String, Expression> cachedExpressions;
63
64 protected static ExpressionParser parser = new SpelExpressionParser();
65
66 private static Method isAssignableFrom;
67 private static Method empty;
68 private static Method emptyList;
69 private static Method listContains;
70 private static Method getName;
71 private static Method getParam;
72 private static Method getParamAsBoolean;
73 private static Method hasPerm;
74 private static Method hasPermDtls;
75 private static Method hasPermTmpl;
76 private static Method sequence;
77 private static Method getDataObjectKey;
78
79 static {
80 try{
81 isAssignableFrom = ExpressionFunctions.class.getDeclaredMethod("isAssignableFrom", new Class[]{Class.class, Class.class});
82 empty = ExpressionFunctions.class.getDeclaredMethod("empty", new Class[]{Object.class});
83 emptyList = ExpressionFunctions.class.getDeclaredMethod("emptyList", new Class[]{List.class});
84 listContains = ExpressionFunctions.class.getDeclaredMethod("listContains", new Class[]{List.class, Object[].class});
85 getName = ExpressionFunctions.class.getDeclaredMethod("getName", new Class[]{Class.class});
86 getParam = ExpressionFunctions.class.getDeclaredMethod("getParam", new Class[]{String.class, String.class, String.class});
87 getParamAsBoolean = ExpressionFunctions.class.getDeclaredMethod("getParamAsBoolean", new Class[]{String.class, String.class, String.class});
88 hasPerm = ExpressionFunctions.class.getDeclaredMethod("hasPerm", new Class[]{String.class, String.class});
89 hasPermDtls = ExpressionFunctions.class.getDeclaredMethod("hasPermDtls", new Class[]{String.class, String.class, Map.class, Map.class});
90 hasPermTmpl = ExpressionFunctions.class.getDeclaredMethod("hasPermTmpl", new Class[]{String.class, String.class, Map.class, Map.class});
91 sequence = ExpressionFunctions.class.getDeclaredMethod("sequence", new Class[]{String.class});
92 getDataObjectKey = ExpressionFunctions.class.getDeclaredMethod("getDataObjectKey", new Class[]{String.class});
93 }catch(NoSuchMethodException e){
94 LOG.error("Custom function for el expressions not found: " + e.getMessage());
95 throw new RuntimeException("Custom function for el expressions not found: " + e.getMessage(), e);
96 }
97 }
98
99
100
101
102 public DefaultExpressionEvaluator() {
103 cachedExpressions = new HashMap<String, Expression>();
104 }
105
106
107
108
109 @Override
110 public void populatePropertyExpressionsFromGraph(UifDictionaryBean expressionConfigurable, boolean buildRefreshGraphs) {
111 if (expressionConfigurable == null || expressionConfigurable.getExpressionGraph() == null) {
112 return;
113 }
114
115
116
117 Map<String, Map<String, String>> refreshExpressionGraphs = new HashMap<String, Map<String, String>>();
118
119 Map<String, String> expressionGraph = expressionConfigurable.getExpressionGraph();
120 for (Map.Entry<String, String> expressionEntry : expressionGraph.entrySet()) {
121 String propertyName = expressionEntry.getKey();
122 String expression = expressionEntry.getValue();
123
124
125 UifDictionaryBean configurableWithExpression = expressionConfigurable;
126
127
128 String adjustedPropertyName = propertyName;
129 if (StringUtils.contains(propertyName, ".")) {
130 String configurablePath = StringUtils.substringBeforeLast(propertyName, ".");
131 adjustedPropertyName = StringUtils.substringAfterLast(propertyName, ".");
132
133 Object nestedObject = ObjectPropertyUtils.getPropertyValue(expressionConfigurable, configurablePath);
134 if ((nestedObject == null) || !(nestedObject instanceof UifDictionaryBean)) {
135 throw new RiceRuntimeException(
136 "Object for which expression is configured on is null or does not implement UifDictionaryBean: '"
137 + configurablePath
138 + "'");
139 }
140
141
142 configurableWithExpression = (UifDictionaryBean) nestedObject;
143
144
145 if (buildRefreshGraphs) {
146 String currentPath = "";
147
148 String[] configurablePathNames = StringUtils.split(configurablePath, ".");
149 for (String configurablePathName : configurablePathNames) {
150 if (StringUtils.isNotBlank(currentPath)) {
151 currentPath += ".";
152 }
153 currentPath += configurablePathName;
154
155 Map<String, String> graphExpressions = null;
156 if (refreshExpressionGraphs.containsKey(currentPath)) {
157 graphExpressions = refreshExpressionGraphs.get(currentPath);
158 } else {
159 graphExpressions = new HashMap<String, String>();
160 refreshExpressionGraphs.put(currentPath, graphExpressions);
161 }
162
163
164 String configurablePropertyName = StringUtils.substringAfter(propertyName, currentPath + ".");
165 graphExpressions.put(configurablePropertyName, expression);
166 }
167 }
168 }
169
170 configurableWithExpression.getPropertyExpressions().put(adjustedPropertyName, expression);
171 }
172 }
173
174
175
176
177 @Override
178 public String parseExpression(String exp, List<String> controlNames, Map<String, Object> context) {
179
180 exp = exp.trim();
181 if (exp.startsWith("@{")) {
182 exp = StringUtils.removeStart(exp, "@{");
183 if (exp.endsWith("}")) {
184 exp = StringUtils.removeEnd(exp, "}");
185 }
186 }
187
188
189 exp = StringUtils.replace(exp, "!=", " != ");
190 exp = StringUtils.replace(exp, "==", " == ");
191 exp = StringUtils.replace(exp, ">", " > ");
192 exp = StringUtils.replace(exp, "<", " < ");
193 exp = StringUtils.replace(exp, "<=", " <= ");
194 exp = StringUtils.replace(exp, ">=", " >= ");
195 exp = StringUtils.replace(exp, "&&", " && ");
196 exp = StringUtils.replace(exp, "||", " || ");
197 exp = StringUtils.replace(exp, " ", " ");
198 exp = StringUtils.replace(exp, " )", ")");
199 exp = StringUtils.replace(exp, "( ", "(");
200 exp = StringUtils.replace(exp, " ,", ",");
201
202 Map<String, String> serverEvaluations = new HashMap<String, String>();
203
204
205 Matcher matcher = SERVER_EVALUATION_PATTERN.matcher(exp);
206 while(matcher.find()) {
207 String spelMethodCall = matcher.group(1);
208
209 Object value = this.evaluateExpression(context, spelMethodCall);
210
211
212 if (value == null) {
213 serverEvaluations.put(spelMethodCall, "null");
214 } else if (value instanceof String) {
215 serverEvaluations.put(spelMethodCall, "\"" + value + "\"");
216 } else if (value instanceof Boolean || NumberUtils.isNumber(value.toString())) {
217 serverEvaluations.put(spelMethodCall, value.toString());
218 } else {
219
220 serverEvaluations.put(spelMethodCall, "\"" + value.toString() + "\"");
221 }
222 }
223
224 String conditionJs = exp;
225 controlNames.addAll(findControlNamesInExpression(exp));
226
227
228 conditionJs = conditionJs.replaceAll("\\s(?i:ne)\\s", " != ").replaceAll("\\s(?i:eq)\\s", " == ").replaceAll(
229 "\\s(?i:gt)\\s", " > ").replaceAll("\\s(?i:lt)\\s", " < ").replaceAll("\\s(?i:lte)\\s", " <= ")
230 .replaceAll("\\s(?i:gte)\\s", " >= ").replaceAll("\\s(?i:and)\\s", " && ").replaceAll("\\s(?i:or)\\s",
231 " || ").replaceAll("\\s(?i:not)\\s", " != ").replaceAll("\\s(?i:null)\\s?", " '' ").replaceAll(
232 "\\s?(?i:#empty)\\((.*?)\\)", "isValueEmpty($1)").replaceAll("\\s?(?i:#listContains)\\((.*?)\\)",
233 "listContains($1)").replaceAll("\\s?(?i:#emptyList)\\((.*?)\\)", "emptyList($1)");
234
235
236 if (conditionJs.contains("matches")) {
237 conditionJs = conditionJs.replaceAll("\\s+(?i:matches)\\s+'.*'", ".match(/" + "$0" + "/) != null ");
238 conditionJs = conditionJs.replaceAll("\\(/\\s+(?i:matches)\\s+'", "(/");
239 conditionJs = conditionJs.replaceAll("'\\s*/\\)", "/)");
240 }
241
242 for (String serverEvalToken: serverEvaluations.keySet()) {
243 String evaluatedValue = serverEvaluations.get(serverEvalToken);
244 conditionJs = conditionJs.replace(serverEvalToken, evaluatedValue);
245 }
246
247 List<String> removeControlNames = new ArrayList<String>();
248 List<String> addControlNames = new ArrayList<String>();
249
250 for (String propertyName : controlNames) {
251
252 if(propertyName.trim().startsWith("{") && propertyName.trim().endsWith("}")){
253 String array = propertyName.trim().replace('{', '[');
254 array = array.replace('}', ']');
255 conditionJs = conditionJs.replace(propertyName, array);
256 removeControlNames.add(propertyName);
257 continue;
258 }
259
260
261 if (propertyName.startsWith("!")){
262 String actualPropertyName = StringUtils.removeStart(propertyName, "!");
263 conditionJs = conditionJs.replace(propertyName,
264 "!coerceValue(\"" + actualPropertyName + "\")");
265 removeControlNames.add(propertyName);
266 addControlNames.add(actualPropertyName);
267 } else {
268 conditionJs = conditionJs.replace(propertyName, "coerceValue(\"" + propertyName + "\")");
269 }
270 }
271
272 controlNames.removeAll(removeControlNames);
273 controlNames.addAll(addControlNames);
274
275
276 boolean complexCondition = conditionJs.contains(" (") || conditionJs.startsWith("(");
277
278
279 if (conditionJs.contains("true && ") || conditionJs.contains(" && true")) {
280 conditionJs = conditionJs.replace(" && true", "");
281 conditionJs = conditionJs.replace("true && ", "");
282 }
283
284
285
286 if (!complexCondition && (conditionJs.contains("false &&")) || conditionJs.contains("&& false") || conditionJs
287 .contains("|| true") || conditionJs.contains("true ||") || conditionJs.equals("true") || conditionJs
288 .equals("false")) {
289 conditionJs = "";
290 }
291
292 return conditionJs;
293 }
294
295
296
297
298 @Override
299 public List<String> findControlNamesInExpression(String exp) {
300 List<String> controlNames = new ArrayList<String>();
301 String stack = "";
302
303 boolean expectingSingleQuote = false;
304 boolean ignoreNext = false;
305 for (int i = 0; i < exp.length(); i++) {
306 char c = exp.charAt(i);
307 if (!expectingSingleQuote && !ignoreNext && (c == '(' || c == ' ' || c == ')')) {
308 evaluateCurrentStack(stack.trim(), controlNames);
309
310 stack = "";
311 continue;
312 } else if (!ignoreNext && c == '\'') {
313 stack = stack + c;
314 expectingSingleQuote = !expectingSingleQuote;
315 } else if (c == '\\') {
316 stack = stack + c;
317 ignoreNext = !ignoreNext;
318 } else {
319 stack = stack + c;
320 ignoreNext = false;
321 }
322 }
323
324 if (StringUtils.isNotEmpty(stack)) {
325 evaluateCurrentStack(stack.trim(), controlNames);
326 }
327
328 return controlNames;
329 }
330
331
332
333
334
335
336
337
338 protected void evaluateCurrentStack(String stack, List<String> controlNames) {
339 if (StringUtils.isBlank(stack)) {
340 return;
341 }
342
343
344 if (!(stack.equals("==")
345 || stack.equals("!=")
346 || stack.equals(">")
347 || stack.equals("<")
348 || stack.equals(">=")
349 || stack.equals("<=")
350 || stack.equalsIgnoreCase("ne")
351 || stack.equalsIgnoreCase("eq")
352 || stack.equalsIgnoreCase("gt")
353 || stack.equalsIgnoreCase("lt")
354 || stack.equalsIgnoreCase("lte")
355 || stack.equalsIgnoreCase("gte")
356 || stack.equalsIgnoreCase("matches")
357 || stack.equalsIgnoreCase("null")
358 || stack.equalsIgnoreCase("false")
359 || stack.equalsIgnoreCase("true")
360 || stack.equalsIgnoreCase("and")
361 || stack.equalsIgnoreCase("or")
362 || stack.startsWith("#")
363 || stack.equals("!")
364 || stack.startsWith("'")
365 || stack.endsWith("'"))) {
366
367
368 boolean isNumber = NumberUtils.isNumber(stack);
369
370
371 if (!(isNumber)) {
372
373 if(StringUtils.endsWith(stack, ",")){
374 stack = StringUtils.removeEnd(stack, ",").trim();
375 }
376
377 if (!controlNames.contains(stack)) {
378 controlNames.add(stack);
379 }
380 }
381 }
382
383 }
384
385
386
387
388 @Override
389 public void initializeEvaluationContext(Object contextObject) {
390 evaluationContext = new StandardEvaluationContext(contextObject);
391
392 addCustomFunctions(evaluationContext);
393 }
394
395
396
397
398 @Override
399 public void evaluateExpressionsOnConfigurable(View view, UifDictionaryBean expressionConfigurable,
400 Map<String, Object> evaluationParameters) {
401 if ((expressionConfigurable instanceof Component) || (expressionConfigurable instanceof LayoutManager)) {
402 evaluatePropertyReplacers(view, expressionConfigurable, evaluationParameters);
403 }
404 evaluatePropertyExpressions(view, expressionConfigurable, evaluationParameters);
405 }
406
407
408
409
410 @Override
411 public Object evaluateExpression(Map<String, Object> evaluationParameters, String expressionStr) {
412 Object result = null;
413
414
415 if (StringUtils.startsWith(expressionStr, UifConstants.EL_PLACEHOLDER_PREFIX) && StringUtils.endsWith(
416 expressionStr, UifConstants.EL_PLACEHOLDER_SUFFIX)) {
417 expressionStr = StringUtils.removeStart(expressionStr, UifConstants.EL_PLACEHOLDER_PREFIX);
418 expressionStr = StringUtils.removeEnd(expressionStr, UifConstants.EL_PLACEHOLDER_SUFFIX);
419 }
420
421 try {
422 Expression expression = retrieveCachedExpression(expressionStr);
423
424 if (evaluationParameters != null) {
425 evaluationContext.setVariables(evaluationParameters);
426 }
427
428 result = expression.getValue(evaluationContext);
429 } catch (Exception e) {
430 LOG.error("Exception evaluating expression: " + expressionStr);
431 throw new RuntimeException("Exception evaluating expression: " + expressionStr, e);
432 }
433
434 return result;
435 }
436
437
438
439
440 @Override
441 public String evaluateExpressionTemplate(Map<String, Object> evaluationParameters, String expressionTemplate) {
442 String result = null;
443
444 try {
445 Expression expression = retrieveCachedExpression(expressionTemplate);
446
447 if (evaluationParameters != null) {
448 evaluationContext.setVariables(evaluationParameters);
449 }
450
451 result = expression.getValue(evaluationContext, String.class);
452 } catch (Exception e) {
453 LOG.error("Exception evaluating expression: " + expressionTemplate);
454 throw new RuntimeException("Exception evaluating expression: " + expressionTemplate, e);
455 }
456
457 return result;
458 }
459
460
461
462
463 @Override
464 public void evaluatePropertyExpression(View view, Map<String, Object> evaluationParameters,
465 UifDictionaryBean expressionConfigurable, String propertyName, boolean removeExpression) {
466
467 Map<String, String> propertyExpressions = expressionConfigurable.getPropertyExpressions();
468 if ((propertyExpressions == null) || !propertyExpressions.containsKey(propertyName)) {
469 return;
470 }
471
472 String expression = propertyExpressions.get(propertyName);
473
474
475 if (CopyUtils.fieldHasAnnotation(expressionConfigurable.getClass(), propertyName, KeepExpression.class)) {
476
477 ObjectPropertyUtils.setPropertyValue(expressionConfigurable, propertyName, expression);
478 return;
479 }
480
481 Object propertyValue = null;
482
483
484 String adjustedExpression = replaceBindingPrefixes(view, expressionConfigurable, expression);
485
486
487 if (StringUtils.startsWith(adjustedExpression, UifConstants.EL_PLACEHOLDER_PREFIX) && StringUtils.endsWith(
488 adjustedExpression, UifConstants.EL_PLACEHOLDER_SUFFIX)
489 && (StringUtils.countMatches(adjustedExpression,
490 UifConstants.EL_PLACEHOLDER_PREFIX) == 1)) {
491 propertyValue = evaluateExpression(evaluationParameters, adjustedExpression);
492 } else {
493
494 propertyValue = evaluateExpressionTemplate(evaluationParameters, adjustedExpression);
495 }
496
497
498
499 if (StringUtils.endsWith(propertyName, ExpressionEvaluator.EMBEDDED_PROPERTY_NAME_ADD_INDICATOR)) {
500 StringUtils.removeEnd(propertyName, ExpressionEvaluator.EMBEDDED_PROPERTY_NAME_ADD_INDICATOR);
501
502 Collection collectionValue = ObjectPropertyUtils.getPropertyValue(expressionConfigurable, propertyName);
503 if (collectionValue == null) {
504 throw new RuntimeException("Property name: "
505 + propertyName
506 + " with collection type was not initialized. Cannot add expression result");
507 }
508 collectionValue.add(propertyValue);
509 } else {
510 ObjectPropertyUtils.setPropertyValue(expressionConfigurable, propertyName, propertyValue);
511 }
512
513 if (removeExpression) {
514 propertyExpressions.remove(propertyName);
515 }
516 }
517
518
519
520
521 @Override
522 public boolean containsElPlaceholder(String value) {
523 boolean containsElPlaceholder = false;
524
525 if (StringUtils.isNotBlank(value)) {
526 String elPlaceholder = StringUtils.substringBetween(value, UifConstants.EL_PLACEHOLDER_PREFIX,
527 UifConstants.EL_PLACEHOLDER_SUFFIX);
528 if (StringUtils.isNotBlank(elPlaceholder)) {
529 containsElPlaceholder = true;
530 }
531 }
532
533 return containsElPlaceholder;
534 }
535
536
537
538
539 @Override
540 public String replaceBindingPrefixes(View view, Object object, String expression) {
541 String adjustedExpression = StringUtils.replace(expression, UifConstants.NO_BIND_ADJUST_PREFIX, "");
542
543
544 if (StringUtils.contains(adjustedExpression, UifConstants.FIELD_PATH_BIND_ADJUST_PREFIX)) {
545 if (object instanceof DataField) {
546
547 BindingInfo bindingInfo = ((DataField) object).getBindingInfo();
548
549 Pattern pattern = Pattern.compile("("
550 + Pattern.quote(UifConstants.FIELD_PATH_BIND_ADJUST_PREFIX)
551 + "[\\.\\w]+"
552 + ")");
553 Matcher matcher = pattern.matcher(adjustedExpression);
554 while (matcher.find()) {
555 String path = matcher.group();
556
557 String adjustedPath = bindingInfo.getPropertyAdjustedBindingPath(path);
558 adjustedExpression = StringUtils.replace(adjustedExpression, path, adjustedPath);
559 }
560 } else {
561 adjustedExpression = StringUtils.replace(adjustedExpression,
562 UifConstants.FIELD_PATH_BIND_ADJUST_PREFIX,
563 "");
564 }
565 }
566
567
568 if (StringUtils.isNotBlank(view.getDefaultBindingObjectPath())) {
569 adjustedExpression = StringUtils.replace(adjustedExpression, UifConstants.DEFAULT_PATH_BIND_ADJUST_PREFIX,
570 view.getDefaultBindingObjectPath() + ".");
571
572 } else {
573 adjustedExpression = StringUtils.replace(adjustedExpression, UifConstants.DEFAULT_PATH_BIND_ADJUST_PREFIX,
574 "");
575 }
576
577
578 if (adjustedExpression.contains(UifConstants.LINE_PATH_BIND_ADJUST_PREFIX) && (object instanceof Component)) {
579 String linePath = getLinePathPrefixValue((Component) object);
580
581 adjustedExpression = StringUtils.replace(adjustedExpression, UifConstants.LINE_PATH_BIND_ADJUST_PREFIX,
582 (StringUtils.isEmpty(linePath) ? linePath : linePath + "."));
583 }
584
585
586 if (adjustedExpression.contains(UifConstants.NODE_PATH_BIND_ADJUST_PREFIX) && (object instanceof Component)) {
587 String nodePath = "";
588
589 Map<String, Object> context = ((Component) object).getContext();
590 if (context != null && context.containsKey(UifConstants.ContextVariableNames.NODE_PATH)) {
591 nodePath = (String) context.get(UifConstants.ContextVariableNames.NODE_PATH);
592 }
593
594 adjustedExpression = StringUtils.replace(adjustedExpression, UifConstants.NODE_PATH_BIND_ADJUST_PREFIX,
595 nodePath + ".");
596 }
597
598 return adjustedExpression;
599 }
600
601
602
603
604
605
606
607
608 protected Expression retrieveCachedExpression(String expressionTemplate) {
609 Expression expression = null;
610
611
612 if (cachedExpressions.containsKey(expressionTemplate)) {
613 return cachedExpressions.get(expressionTemplate);
614 }
615
616
617 if (StringUtils.contains(expressionTemplate, UifConstants.EL_PLACEHOLDER_PREFIX)) {
618 expression = parser.parseExpression(expressionTemplate, new TemplateParserContext(
619 UifConstants.EL_PLACEHOLDER_PREFIX, UifConstants.EL_PLACEHOLDER_SUFFIX));
620 } else {
621 expression = parser.parseExpression(expressionTemplate);
622 }
623
624 synchronized (cachedExpressions) {
625 cachedExpressions.put(expressionTemplate, expression);
626 }
627
628 return expression;
629 }
630
631
632
633
634
635
636 protected void addCustomFunctions(StandardEvaluationContext context) {
637 context.registerFunction("isAssignableFrom", isAssignableFrom);
638 context.registerFunction("empty", empty);
639 context.registerFunction("emptyList", emptyList);
640 context.registerFunction("listContains", listContains);
641 context.registerFunction("getName", getName);
642 context.registerFunction("getParam", getParam);
643 context.registerFunction("getParamAsBoolean", getParamAsBoolean);
644 context.registerFunction("hasPerm", hasPerm);
645 context.registerFunction("hasPermDtls", hasPermDtls);
646 context.registerFunction("hasPermTmpl", hasPermTmpl);
647 context.registerFunction("sequence", sequence);
648 context.registerFunction("getDataObjectKey", getDataObjectKey);
649 }
650
651
652
653
654
655
656
657
658
659
660
661 protected void evaluatePropertyReplacers(View view, UifDictionaryBean expressionConfigurable,
662 Map<String, Object> evaluationParameters) {
663 List<PropertyReplacer> replacers = null;
664 if (Component.class.isAssignableFrom(expressionConfigurable.getClass())) {
665 replacers = ((Component) expressionConfigurable).getPropertyReplacers();
666 } else if (LayoutManager.class.isAssignableFrom(expressionConfigurable.getClass())) {
667 replacers = ((LayoutManager) expressionConfigurable).getPropertyReplacers();
668 }
669
670 if (replacers != null) {
671 for (PropertyReplacer propertyReplacer : replacers) {
672 String expression = propertyReplacer.getCondition();
673 String adjustedExpression = replaceBindingPrefixes(view, expressionConfigurable, expression);
674
675 String conditionEvaluation = evaluateExpressionTemplate(evaluationParameters, adjustedExpression);
676 boolean conditionSuccess = Boolean.parseBoolean(conditionEvaluation);
677 if (conditionSuccess) {
678 ObjectPropertyUtils.setPropertyValue(expressionConfigurable, propertyReplacer.getPropertyName(),
679 propertyReplacer.getReplacement());
680 }
681 }
682 }
683 }
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700 protected void evaluatePropertyExpressions(View view, UifDictionaryBean expressionConfigurable,
701 Map<String, Object> evaluationParameters) {
702 if (expressionConfigurable == null) {
703 return;
704 }
705
706 Map<String, String> propertyExpressions = expressionConfigurable.getPropertyExpressions();
707 if (propertyExpressions == null){
708 return;
709 }
710
711 for (String propertyName : propertyExpressions.keySet()) {
712 evaluatePropertyExpression(view, evaluationParameters, expressionConfigurable, propertyName, false);
713 }
714 }
715
716
717
718
719
720
721
722
723
724 protected static String getLinePathPrefixValue(Component component) {
725 Map<String, Object> componentContext = component.getContext();
726 if (componentContext == null) {
727 return "";
728 }
729
730 CollectionGroup collectionGroup = (CollectionGroup) (componentContext.get(
731 UifConstants.ContextVariableNames.COLLECTION_GROUP));
732 if (collectionGroup == null) {
733 LOG.warn("collection group not found for " + component + "," + component.getId() + ", " + component
734 .getComponentTypeName());
735 return "";
736 }
737
738 String linePath = "";
739
740 Integer indexObj = (Integer) componentContext.get(UifConstants.ContextVariableNames.INDEX);
741 if (indexObj != null) {
742 int index = indexObj.intValue();
743
744 boolean addLine = false;
745 Boolean addLineObj = (Boolean) componentContext.get(UifConstants.ContextVariableNames.IS_ADD_LINE);
746
747 if (addLineObj != null) {
748 addLine = addLineObj.booleanValue();
749 }
750
751 if (addLine) {
752 linePath = collectionGroup.getAddLineBindingInfo().getBindingPath();
753 } else {
754 linePath = collectionGroup.getBindingInfo().getBindingPath() + "[" + index + "]";
755 }
756 }
757
758 return linePath;
759 }
760
761 }