1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.kuali.rice.krad.uif.util;
17
18 import org.apache.commons.lang.StringUtils;
19 import org.kuali.rice.krad.datadictionary.state.StateMapping;
20 import org.kuali.rice.krad.datadictionary.validation.constraint.BaseConstraint;
21 import org.kuali.rice.krad.datadictionary.validation.constraint.CaseConstraint;
22 import org.kuali.rice.krad.datadictionary.validation.constraint.Constraint;
23 import org.kuali.rice.krad.datadictionary.validation.constraint.MustOccurConstraint;
24 import org.kuali.rice.krad.datadictionary.validation.constraint.PrerequisiteConstraint;
25 import org.kuali.rice.krad.datadictionary.validation.constraint.SimpleConstraint;
26 import org.kuali.rice.krad.datadictionary.validation.constraint.ValidCharactersConstraint;
27 import org.kuali.rice.krad.datadictionary.validation.constraint.WhenConstraint;
28 import org.kuali.rice.krad.messages.MessageService;
29 import org.kuali.rice.krad.service.KRADServiceLocatorWeb;
30 import org.kuali.rice.krad.uif.UifConstants;
31 import org.kuali.rice.krad.uif.control.TextControl;
32 import org.kuali.rice.krad.uif.field.InputField;
33 import org.kuali.rice.krad.uif.view.FormView;
34 import org.kuali.rice.krad.uif.view.View;
35 import org.kuali.rice.krad.util.KRADUtils;
36
37 import java.text.MessageFormat;
38 import java.util.ArrayList;
39 import java.util.EnumSet;
40 import java.util.List;
41
42
43
44
45
46
47
48
49
50
51 public class ClientValidationUtils {
52
53 private static int methodKey = 0;
54
55
56
57 private static List<List<String>> mustOccursPathNames;
58
59 public static final String LABEL_KEY_SPLIT_PATTERN = ",";
60
61 public static final String PREREQ_MSG_KEY = "prerequisite";
62 public static final String POSTREQ_MSG_KEY = "postrequisite";
63 public static final String MUSTOCCURS_MSG_KEY = "mustOccurs";
64 public static final String MUSTOCCURS_MSG_EQUAL_KEY = "mustOccursEqualMinMax";
65 public static final String GENERIC_FIELD_MSG_KEY = "general.genericFieldName";
66
67 public static final String ALL_MSG_KEY = "general.all";
68 public static final String ATMOST_MSG_KEY = "general.atMost";
69 public static final String AND_MSG_KEY = "general.and";
70 public static final String OR_MSG_KEY = "general.or";
71
72
73 public static enum ValidationMessageKeys {
74 REQUIRED("required"),
75 MIN_EXCLUSIVE("minExclusive"),
76 MAX_INCLUSIVE("maxInclusive"),
77 MIN_LENGTH("minLengthConditional"),
78 MAX_LENGTH("maxLengthConditional");
79
80 private ValidationMessageKeys(String name) {
81 this.name = name;
82 }
83
84 private final String name;
85
86 @Override
87 public String toString() {
88 return name;
89 }
90
91 public static boolean contains(String name) {
92 for (ValidationMessageKeys element : EnumSet.allOf(ValidationMessageKeys.class)) {
93 if (element.toString().equalsIgnoreCase(name)) {
94 return true;
95 }
96 }
97 return false;
98 }
99 }
100
101
102
103
104
105
106
107
108
109
110
111
112 public static String generateMessageText(String namespace, String componentCode, String messageKey,
113 List<String> params) {
114 String message = "NO MESSAGE";
115 if (StringUtils.isNotEmpty(messageKey)) {
116 message = KRADServiceLocatorWeb.getMessageService().getMessageText(namespace, componentCode, messageKey);
117 if (params != null && !params.isEmpty() && StringUtils.isNotEmpty(message)) {
118 message = MessageFormat.format(message, params.toArray());
119 message = MessageStructureUtils.translateStringMessage(message);
120 }
121 }
122
123 if (StringUtils.isEmpty(message)) {
124 message = messageKey;
125 }
126
127
128 message = KRADUtils.convertToHTMLAttributeSafeString(message);
129
130 return message;
131 }
132
133
134
135
136
137
138
139 public static String generateValidatorMessagesOption() {
140 MessageService messageService = KRADServiceLocatorWeb.getMessageService();
141
142 String mOption = "";
143 String keyValuePairs = "";
144 for (ValidationMessageKeys element : EnumSet.allOf(ValidationMessageKeys.class)) {
145 String key = element.toString();
146 String message = messageService.getMessageText(UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + key);
147
148 if (StringUtils.isNotEmpty(message)) {
149 message = MessageStructureUtils.translateStringMessage(message);
150 keyValuePairs = keyValuePairs + "\n" + key + ": '" + message + "',";
151 }
152 }
153
154 keyValuePairs = StringUtils.removeEnd(keyValuePairs, ",");
155 if (StringUtils.isNotEmpty(keyValuePairs)) {
156 mOption = "{" + keyValuePairs + "}";
157 }
158
159 return mOption;
160 }
161
162
163
164
165
166
167
168
169 public static String getRegexMethod(InputField field, ValidCharactersConstraint validCharactersConstraint) {
170 String message = generateMessageText(validCharactersConstraint.getMessageNamespaceCode(),
171 validCharactersConstraint.getMessageComponentCode(), validCharactersConstraint.getMessageKey(),
172 validCharactersConstraint.getValidationMessageParams());
173 String key = "validChar-" + field.getBindingInfo().getBindingPath() + methodKey;
174
175
176 String regex = validCharactersConstraint.getValue();
177 if (regex.contains("\\\\")) {
178 regex = regex.replaceAll("\\\\", "\\\\\\\\");
179 }
180 if (regex.contains("/")) {
181 regex = regex.replace("/", "\\/");
182 }
183
184 return "\njQuery.validator.addMethod(\""
185 + ScriptUtils.escapeName(key)
186 + "\", function(value, element) {\n "
187 + "return this.optional(element) || /"
188 + regex
189 + "/.test(value);"
190 + "}, \""
191 + message
192 + "\");";
193 }
194
195
196
197
198
199
200
201
202
203 public static String getRegexMethodWithBooleanCheck(InputField field,
204 ValidCharactersConstraint validCharactersConstraint) {
205 String message = generateMessageText(validCharactersConstraint.getMessageNamespaceCode(),
206 validCharactersConstraint.getMessageComponentCode(), validCharactersConstraint.getMessageKey(),
207 validCharactersConstraint.getValidationMessageParams());
208 String key = "validChar-" + field.getBindingInfo().getBindingPath() + methodKey;
209
210
211 String regex = validCharactersConstraint.getValue();
212 if (regex.contains("\\\\")) {
213 regex = regex.replaceAll("\\\\", "\\\\\\\\");
214 }
215 if (regex.contains("/")) {
216 regex = regex.replace("/", "\\/");
217 }
218
219 return "\njQuery.validator.addMethod(\""
220 + ScriptUtils.escapeName(key)
221 + "\", function(value, element, doCheck) {\n if(doCheck === false){return true;}else{"
222 + "return this.optional(element) || /"
223 + regex
224 + "/.test(value);}"
225 + "}, \""
226 + message
227 + "\");";
228 }
229
230
231
232
233
234
235
236
237
238
239
240 public static void processCaseConstraint(InputField field, View view, CaseConstraint constraint, String andedCase,
241 String validationState, StateMapping stateMapping) {
242 if (constraint.getOperator() == null) {
243 constraint.setOperator("equals");
244 }
245
246 String operator = "==";
247 if (constraint.getOperator().equalsIgnoreCase("not_equals") || constraint.getOperator().equalsIgnoreCase(
248 "not_equal")) {
249 operator = "!=";
250 } else if (constraint.getOperator().equalsIgnoreCase("greater_than_equal")) {
251 operator = ">=";
252 } else if (constraint.getOperator().equalsIgnoreCase("less_than_equal")) {
253 operator = "<=";
254 } else if (constraint.getOperator().equalsIgnoreCase("greater_than")) {
255 operator = ">";
256 } else if (constraint.getOperator().equalsIgnoreCase("less_than")) {
257 operator = "<";
258 } else if (constraint.getOperator().equalsIgnoreCase("has_value")) {
259 operator = "";
260 }
261
262
263 field.getControl().addStyleClass("dependsOn-" + ScriptUtils.escapeName(constraint.getPropertyName()));
264
265 if (constraint.getWhenConstraint() != null && !constraint.getWhenConstraint().isEmpty()) {
266
267 String fieldPath = constraint.getPropertyName();
268 for (WhenConstraint wc : constraint.getWhenConstraint()) {
269 wc = ConstraintStateUtils.getApplicableConstraint(wc, validationState, stateMapping);
270 if (wc != null) {
271 processWhenConstraint(field, view, constraint, wc, ScriptUtils.escapeName(fieldPath), operator,
272 andedCase, validationState, stateMapping);
273 }
274 }
275 }
276 }
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291 private static void processWhenConstraint(InputField field, View view, CaseConstraint caseConstraint,
292 WhenConstraint wc, String fieldPath, String operator, String andedCase, String validationState,
293 StateMapping stateMapping) {
294 String ruleString = "";
295
296
297 String booleanStatement = "";
298 if (wc.getValues() != null) {
299
300 String caseStr = "";
301 if (!caseConstraint.isCaseSensitive()) {
302 caseStr = ".toUpperCase()";
303 }
304 for (int i = 0; i < wc.getValues().size(); i++) {
305 if (operator.isEmpty()) {
306
307 if (wc.getValues().get(i) instanceof String && ((String) wc.getValues().get(i)).equalsIgnoreCase(
308 "false")) {
309 booleanStatement = booleanStatement + "(coerceValue('" + fieldPath + "') == '')";
310 } else {
311 booleanStatement = booleanStatement + "(coerceValue('" + fieldPath + "') != '')";
312 }
313 } else {
314
315 booleanStatement = booleanStatement
316 + "(coerceValue('"
317 + fieldPath
318 + "')"
319 + caseStr
320 + " "
321 + operator
322 + " \""
323 + wc.getValues().get(i)
324 + "\""
325 + caseStr
326 + ")";
327 }
328 if ((i + 1) != wc.getValues().size()) {
329 booleanStatement = booleanStatement + " || ";
330 }
331 }
332
333 }
334
335 if (andedCase != null) {
336 booleanStatement = "(" + booleanStatement + ") && (" + andedCase + ")";
337 }
338
339 if (wc.getConstraint() != null && StringUtils.isNotEmpty(booleanStatement)) {
340 Constraint constraint = ConstraintStateUtils.getApplicableConstraint(wc.getConstraint(), validationState,
341 stateMapping);
342 if (constraint != null) {
343 ruleString = createRule(field, constraint, booleanStatement, view, validationState, stateMapping);
344 }
345 }
346
347 if (StringUtils.isNotEmpty(ruleString)) {
348 addScriptToPage(view, field, ruleString);
349 }
350 }
351
352
353
354
355
356
357
358 public static void addScriptToPage(View view, InputField field, String script) {
359 String prefixScript = "";
360
361 if (field.getOnDocumentReadyScript() != null) {
362 prefixScript = field.getOnDocumentReadyScript();
363 }
364 field.setOnDocumentReadyScript(prefixScript + "\n" + "runValidationScript(function(){" + script + "});");
365 }
366
367
368
369
370
371
372
373
374 private static List<String> parseOutFields(String statement) {
375 List<String> fieldNames = new ArrayList<String>();
376 String[] splits = StringUtils.splitByWholeSeparator(statement, "coerceValue(");
377 for (String s : splits) {
378
379 if(!s.startsWith("'")){
380 continue;
381 }
382
383 s = s.substring(1);
384 String fieldName = StringUtils.substringBefore(s, "'");
385
386 if(fieldNames.contains(fieldName)){
387 fieldNames.add(fieldName);
388 }
389
390 }
391 return fieldNames;
392 }
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410 @SuppressWarnings("boxing")
411 private static String createRule(InputField field, Constraint constraint, String booleanStatement, View view,
412 String validationState, StateMapping stateMapping) {
413 String rule = "";
414 int constraintCount = 0;
415 if (constraint instanceof BaseConstraint && ((BaseConstraint) constraint).getApplyClientSide()) {
416 if (constraint instanceof SimpleConstraint) {
417 if (((SimpleConstraint) constraint).getRequired() != null && ((SimpleConstraint) constraint)
418 .getRequired()) {
419 rule = rule + "required: function(element){\nreturn (" + booleanStatement + ");}";
420
421 String showIndicatorScript = "";
422 for (String checkedField : parseOutFields(booleanStatement)) {
423 showIndicatorScript = showIndicatorScript +
424 "setupShowReqIndicatorCheck('" + checkedField + "', '" + field.getBindingInfo()
425 .getBindingPath() + "', " + "function(){\nreturn (" + booleanStatement + ");});\n";
426 }
427 addScriptToPage(view, field, showIndicatorScript);
428
429 constraintCount++;
430 }
431
432 if (((SimpleConstraint) constraint).getMinLength() != null) {
433 if (constraintCount > 0) {
434 rule = rule + ",\n";
435 }
436 rule = rule
437 + "minLengthConditional: ["
438 + ((SimpleConstraint) constraint).getMinLength()
439 + ", function(){return "
440 + booleanStatement
441 + ";}]";
442 constraintCount++;
443 }
444
445 if (((SimpleConstraint) constraint).getMaxLength() != null) {
446 if (constraintCount > 0) {
447 rule = rule + ",\n";
448 }
449 rule = rule
450 + "maxLengthConditional: ["
451 + ((SimpleConstraint) constraint).getMaxLength()
452 + ", function(){return "
453 + booleanStatement
454 + ";}]";
455 constraintCount++;
456 }
457
458 if (((SimpleConstraint) constraint).getExclusiveMin() != null) {
459 if (constraintCount > 0) {
460 rule = rule + ",\n";
461 }
462 rule = rule
463 + "minExclusive: ["
464 + ((SimpleConstraint) constraint).getExclusiveMin()
465 + ", function(){return "
466 + booleanStatement
467 + ";}]";
468 constraintCount++;
469 }
470
471 if (((SimpleConstraint) constraint).getInclusiveMax() != null) {
472 if (constraintCount > 0) {
473 rule = rule + ",\n";
474 }
475 rule = rule
476 + "maxInclusive: ["
477 + ((SimpleConstraint) constraint).getInclusiveMax()
478 + ", function(){return "
479 + booleanStatement
480 + ";}]";
481 constraintCount++;
482 }
483
484 rule = "jQuery('[name=\""
485 + ScriptUtils.escapeName(field.getBindingInfo().getBindingPath())
486 + "\"]').rules(\"add\", {"
487 + rule
488 + "\n});";
489 } else if (constraint instanceof ValidCharactersConstraint) {
490 String regexMethod = "";
491 String methodName = "";
492 if (StringUtils.isNotEmpty(((ValidCharactersConstraint) constraint).getValue())) {
493 regexMethod = ClientValidationUtils.getRegexMethodWithBooleanCheck(field,
494 (ValidCharactersConstraint) constraint) + "\n";
495 methodName = "validChar-" + field.getBindingInfo().getBindingPath() + methodKey;
496 methodKey++;
497 } else {
498 if (StringUtils.isNotEmpty(((ValidCharactersConstraint) constraint).getMessageKey())) {
499 methodName = ((ValidCharactersConstraint) constraint).getMessageKey();
500 }
501 }
502
503 if (StringUtils.isNotEmpty(methodName)) {
504 rule = regexMethod
505 + "jQuery('[name=\""
506 + ScriptUtils.escapeName(field.getBindingInfo().getBindingPath())
507 + "\"]').rules(\"add\", {\n\""
508 + methodName
509 + "\" : function(element){return ("
510 + booleanStatement
511 + ");}\n});";
512 }
513 } else if (constraint instanceof PrerequisiteConstraint) {
514 processPrerequisiteConstraint(field, (PrerequisiteConstraint) constraint, view, booleanStatement);
515 } else if (constraint instanceof CaseConstraint) {
516 processCaseConstraint(field, view, (CaseConstraint) constraint, booleanStatement, validationState,
517 stateMapping);
518 } else if (constraint instanceof MustOccurConstraint) {
519 processMustOccurConstraint(field, view, (MustOccurConstraint) constraint, booleanStatement);
520 }
521 }
522
523 return rule;
524 }
525
526
527
528
529
530
531
532
533
534 public static void processPrerequisiteConstraint(InputField field, PrerequisiteConstraint constraint, View view) {
535 processPrerequisiteConstraint(field, constraint, view, "true");
536 }
537
538
539
540
541
542
543
544
545
546
547 public static void processPrerequisiteConstraint(InputField field, PrerequisiteConstraint constraint, View view,
548 String booleanStatement) {
549 if (constraint != null && constraint.getApplyClientSide().booleanValue()) {
550 String dependsClass = "dependsOn-" + ScriptUtils.escapeName(constraint.getPropertyName());
551 String addClass = "jQuery('[name=\""
552 + ScriptUtils.escapeName(field.getBindingInfo().getBindingPath())
553 + "\"]').addClass('"
554 + dependsClass
555 + "');"
556 +
557 "jQuery('[name=\""
558 + ScriptUtils.escapeName(constraint.getPropertyName())
559 + "\"]').addClass('"
560 + "dependsOn-"
561 + ScriptUtils.escapeName(field.getBindingInfo().getBindingPath())
562 + "');";
563
564 addScriptToPage(view, field, addClass
565 + getPrerequisiteStatement(field, view, constraint, booleanStatement)
566 + getPostrequisiteStatement(field, constraint, booleanStatement));
567
568
569 String showIndicatorScript = "setupShowReqIndicatorCheck('" + ScriptUtils.escapeName(
570 field.getBindingInfo().getBindingPath()) + "', '" + ScriptUtils.escapeName(
571 constraint.getPropertyName()) + "', " + "function(){\nreturn (coerceValue('" + ScriptUtils
572 .escapeName(field.getBindingInfo().getBindingPath()) + "') && " + booleanStatement + ");});\n";
573
574 addScriptToPage(view, field, showIndicatorScript);
575 }
576 }
577
578
579
580
581
582
583
584
585
586
587
588
589
590 private static String getPrerequisiteStatement(InputField field, View view, PrerequisiteConstraint constraint,
591 String booleanStatement) {
592 methodKey++;
593
594 MessageService messageService = KRADServiceLocatorWeb.getMessageService();
595
596 String message = "";
597 if (StringUtils.isEmpty(constraint.getMessageKey())) {
598 message = messageService.getMessageText(UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "prerequisite");
599 message = MessageStructureUtils.translateStringMessage(message);
600 } else {
601 message = generateMessageText(constraint.getMessageNamespaceCode(),
602 constraint.getMessageComponentCode(), constraint.getMessageKey(),
603 constraint.getValidationMessageParams());
604 }
605
606 if (StringUtils.isEmpty(message)) {
607 message = "prerequisite - No message";
608 } else {
609 InputField requiredField = (InputField) view.getViewIndex().getDataFieldByPath(
610 constraint.getPropertyName());
611 if (requiredField != null && StringUtils.isNotEmpty(requiredField.getLabel())) {
612 message = MessageFormat.format(message, requiredField.getLabel());
613 } else {
614 String genericFieldLabel = messageService.getMessageText(GENERIC_FIELD_MSG_KEY);
615 message = MessageFormat.format(message, genericFieldLabel);
616 }
617 }
618
619
620 String methodName = "prConstraint-"
621 + ScriptUtils.escapeName(field.getBindingInfo().getBindingPath())
622 + methodKey;
623
624 String addClass = "jQuery('[name=\""
625 + ScriptUtils.escapeName(field.getBindingInfo().getBindingPath())
626 + "\"]').addClass('"
627 + methodName
628 + "');\n";
629
630 String method = "\njQuery.validator.addMethod(\"" + methodName + "\", function(value, element) {\n" +
631 " if(" + booleanStatement + "){ return (this.optional(element) || (coerceValue('" + ScriptUtils
632 .escapeName(constraint.getPropertyName()) + "')));}else{return true;} " +
633 "}, \"" + message + "\");";
634
635 String ifStatement = "if(occursBefore('"
636 + ScriptUtils.escapeName(constraint.getPropertyName())
637 + "','"
638 + ScriptUtils.escapeName(field.getBindingInfo().getBindingPath())
639 +
640 "')){"
641 + addClass
642 + method
643 + "}";
644
645 return ifStatement;
646 }
647
648
649
650
651
652
653
654
655
656
657
658
659 private static String getPostrequisiteStatement(InputField field, PrerequisiteConstraint constraint,
660 String booleanStatement) {
661 MessageService messageService = KRADServiceLocatorWeb.getMessageService();
662
663
664 String message = "";
665 if (StringUtils.isEmpty(constraint.getMessageKey())) {
666 message = messageService.getMessageText(UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "postrequisite");
667 message = MessageStructureUtils.translateStringMessage(message);
668 } else {
669 message = generateMessageText(constraint.getMessageNamespaceCode(), constraint.getMessageComponentCode(),
670 constraint.getMessageKey(), constraint.getValidationMessageParams());
671 }
672
673 if (StringUtils.isEmpty(constraint.getMessageKey())) {
674 if (StringUtils.isNotEmpty(field.getLabel())) {
675 message = MessageFormat.format(message, field.getLabel());
676 } else {
677 String genericFieldLabel = messageService.getMessageText(GENERIC_FIELD_MSG_KEY);
678 message = MessageFormat.format(message, genericFieldLabel);
679 }
680 }
681
682 String function = "function(element){\n" +
683 "return (coerceValue('"
684 + ScriptUtils.escapeName(field.getBindingInfo().getBindingPath())
685 + "') && "
686 + booleanStatement
687 + ");}";
688 String postStatement = "\nelse if(occursBefore('"
689 + ScriptUtils.escapeName(field.getBindingInfo().getBindingPath())
690 + "','"
691 + ScriptUtils.escapeName(constraint.getPropertyName())
692 +
693 "')){\njQuery('[name=\""
694 + ScriptUtils.escapeName(constraint.getPropertyName())
695 +
696 "\"]').rules(\"add\", { required: \n"
697 + function
698 + ", \nmessages: {\nrequired: \""
699 + message
700 + "\"}});}\n";
701
702 return postStatement;
703
704 }
705
706
707
708
709
710
711
712
713
714
715
716
717 public static void processMustOccurConstraint(InputField field, View view, MustOccurConstraint mc,
718 String booleanStatement) {
719 methodKey++;
720 mustOccursPathNames = new ArrayList<List<String>>();
721
722 String methodName = "moConstraint-"
723 + ScriptUtils.escapeName(field.getBindingInfo().getBindingPath())
724 + methodKey;
725 String method = "\njQuery.validator.addMethod(\"" + methodName + "\", function(value, element) {\n" +
726 " if("
727 + booleanStatement
728 + "){return (this.optional(element) || ("
729 + getMustOccurStatement(field, mc)
730 + "));}else{return true;}"
731 +
732 "}, \""
733 + getMustOccursMessage(view, mc)
734 + "\");";
735 String rule = method
736 + "jQuery('[name=\""
737 + ScriptUtils.escapeName(field.getBindingInfo().getBindingPath())
738 + "\"]').rules(\"add\", {\n\""
739 + methodName
740 + "\": function(element){return ("
741 + booleanStatement
742 + ");}\n});";
743 addScriptToPage(view, field, rule);
744 }
745
746
747
748
749
750
751
752
753
754
755
756 @SuppressWarnings("boxing")
757 private static String getMustOccurStatement(InputField field, MustOccurConstraint constraint) {
758 String statement = "";
759 List<String> attributePaths = new ArrayList<String>();
760 if (constraint != null && constraint.getApplyClientSide()) {
761 String array = "[";
762 if (constraint.getPrerequisiteConstraints() != null) {
763 for (int i = 0; i < constraint.getPrerequisiteConstraints().size(); i++) {
764 field.getControl().addStyleClass("dependsOn-" + constraint.getPrerequisiteConstraints().get(i)
765 .getPropertyName());
766 array = array + "'" + ScriptUtils.escapeName(constraint.getPrerequisiteConstraints().get(i)
767 .getPropertyName()) + "'";
768 attributePaths.add(constraint.getPrerequisiteConstraints().get(i).getPropertyName());
769 if (i + 1 != constraint.getPrerequisiteConstraints().size()) {
770 array = array + ",";
771 }
772
773 }
774 }
775 array = array + "]";
776 statement = "mustOccurTotal(" + array + ", " + constraint.getMin() + ", " + constraint.getMax() + ")";
777
778 if (constraint.getMin() != null) {
779 attributePaths.add(constraint.getMin().toString());
780 } else {
781 attributePaths.add(null);
782 }
783
784 if (constraint.getMax() != null) {
785 attributePaths.add(constraint.getMax().toString());
786 } else {
787 attributePaths.add(null);
788 }
789
790 mustOccursPathNames.add(attributePaths);
791 if (StringUtils.isEmpty(statement)) {
792 statement = "0";
793 }
794 if (constraint.getMustOccurConstraints() != null) {
795 for (MustOccurConstraint mc : constraint.getMustOccurConstraints()) {
796 statement = "mustOccurCheck(" + statement + " + " + getMustOccurStatement(field, mc) +
797 ", " + constraint.getMin() + ", " + constraint.getMax() + ")";
798 }
799 } else {
800 statement = "mustOccurCheck(" + statement +
801 ", " + constraint.getMin() + ", " + constraint.getMax() + ")";
802 }
803 }
804 return statement;
805 }
806
807
808
809
810
811
812
813
814
815
816 private static String getMustOccursMessage(View view, MustOccurConstraint constraint) {
817 MessageService messageService = KRADServiceLocatorWeb.getMessageService();
818
819 String message = "";
820 if (StringUtils.isNotEmpty(constraint.getMessageKey())) {
821 message = generateMessageText(constraint.getMessageNamespaceCode(), constraint.getMessageComponentCode(),
822 constraint.getMessageKey(), constraint.getValidationMessageParams());
823 } else {
824 String and = messageService.getMessageText(AND_MSG_KEY);
825 String or = messageService.getMessageText(OR_MSG_KEY);
826 String all = messageService.getMessageText(ALL_MSG_KEY);
827 String mustOccursMsgEqualMinMax = messageService.getMessageText(
828 UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + MUSTOCCURS_MSG_EQUAL_KEY);
829 String atMost = messageService.getMessageText(ATMOST_MSG_KEY);
830 String genericLabel = messageService.getMessageText(GENERIC_FIELD_MSG_KEY);
831 String mustOccursMsg = messageService.getMessageText(
832 UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + MUSTOCCURS_MSG_KEY);
833
834 String statement = "";
835 for (int i = 0; i < mustOccursPathNames.size(); i++) {
836 String andedString = "";
837
838 List<String> paths = mustOccursPathNames.get(i);
839 if (!paths.isEmpty()) {
840
841 String min = paths.get(paths.size() - 2);
842 String max = paths.get(paths.size() - 1);
843 for (int j = 0; j < paths.size() - 2; j++) {
844 InputField field = (InputField) view.getViewIndex().getDataFieldByPath(paths.get(j).trim());
845 String label = genericLabel;
846 if (field != null && StringUtils.isNotEmpty(field.getLabel())) {
847 label = field.getLabel();
848 }
849 if (min.equals(max)) {
850 if (j == 0) {
851 andedString = label;
852 } else if (j == paths.size() - 3) {
853 andedString = andedString + " " + and + " " + label;
854 } else {
855 andedString = andedString + ", " + label;
856 }
857 } else {
858 andedString = andedString + "(" + label + ")";
859 }
860 }
861 if (min.equals(max)) {
862 andedString = "(" + andedString + ")";
863 }
864
865 if (StringUtils.isNotBlank(andedString) && !andedString.equals("()")) {
866 if (StringUtils.isNotEmpty(min) && StringUtils.isNotEmpty(max) && !min.equals(max)) {
867 andedString = MessageFormat.format(mustOccursMsg, min + "-" + max) + " " + andedString;
868 } else if (StringUtils.isNotEmpty(min)
869 && StringUtils.isNotEmpty(max)
870 && min.equals(max)
871 && i == 0) {
872 andedString = mustOccursMsgEqualMinMax + " " + andedString;
873 } else if (StringUtils.isNotEmpty(min)
874 && StringUtils.isNotEmpty(max)
875 && min.equals(max)
876 && i != 0) {
877
878 } else if (StringUtils.isNotEmpty(min)) {
879 andedString = MessageFormat.format(mustOccursMsg, min) + " " + andedString;
880 } else if (StringUtils.isNotEmpty(max)) {
881 andedString = MessageFormat.format(mustOccursMsg, atMost + " " + max) + " " + andedString;
882 }
883 }
884 }
885 if (StringUtils.isNotEmpty(andedString)) {
886 if (StringUtils.isNotBlank(statement)) {
887 statement = statement + " " + or.toUpperCase() + " " + andedString;
888 } else {
889 statement = andedString;
890 }
891 }
892 }
893 if (StringUtils.isNotEmpty(statement)) {
894 message = statement;
895 message = message.replace(")(", " " + or + " ");
896 }
897 }
898
899 return message;
900 }
901
902
903
904
905
906
907
908
909
910 @SuppressWarnings("boxing")
911 public static void processAndApplyConstraints(InputField field, View view, Object model) {
912 methodKey = 0;
913 String validationState = ConstraintStateUtils.getClientViewValidationState(model, view);
914 StateMapping stateMapping = view.getStateMapping();
915
916 if (view instanceof FormView && ((FormView) view).isValidateClientSide()) {
917 SimpleConstraint simpleConstraint = ConstraintStateUtils.getApplicableConstraint(
918 field.getSimpleConstraint(), validationState, stateMapping);
919 if (simpleConstraint != null && simpleConstraint.getApplyClientSide()) {
920
921 if ((simpleConstraint.getRequired() != null) && (simpleConstraint.getRequired().booleanValue())) {
922 field.getControl().addStyleClass("required");
923 }
924
925 if (simpleConstraint.getExclusiveMin() != null) {
926 if (field.getControl() instanceof TextControl
927 && ((TextControl) field.getControl()).getDatePicker() != null) {
928 ((TextControl) field.getControl()).getDatePicker().getTemplateOptions().put("minDate",
929 simpleConstraint.getExclusiveMin());
930 } else {
931 String rule = "jQuery('[name=\""
932 + ScriptUtils.escapeName(field.getBindingInfo().getBindingPath())
933 + "\"]').rules(\"add\", {\n minExclusive: ["
934 + simpleConstraint.getExclusiveMin()
935 + "]});";
936 addScriptToPage(view, field, rule);
937 }
938 }
939
940 if (simpleConstraint.getInclusiveMax() != null) {
941 if (field.getControl() instanceof TextControl
942 && ((TextControl) field.getControl()).getDatePicker() != null) {
943 ((TextControl) field.getControl()).getDatePicker().getTemplateOptions().put("maxDate",
944 simpleConstraint.getInclusiveMax());
945 } else {
946 String rule = "jQuery('[name=\""
947 + ScriptUtils.escapeName(field.getBindingInfo().getBindingPath())
948 + "\"]').rules(\"add\", {\n maxInclusive: ["
949 + simpleConstraint.getInclusiveMax()
950 + "]});";
951 addScriptToPage(view, field, rule);
952 }
953 }
954 }
955
956 ValidCharactersConstraint validCharactersConstraint = ConstraintStateUtils.getApplicableConstraint(
957 field.getValidCharactersConstraint(), validationState, stateMapping);
958
959 if (validCharactersConstraint != null && validCharactersConstraint.getApplyClientSide()) {
960 if (StringUtils.isNotEmpty(validCharactersConstraint.getValue())) {
961
962 addScriptToPage(view, field, ClientValidationUtils.getRegexMethod(field,
963 validCharactersConstraint));
964 field.getControl().addStyleClass(
965 "validChar-" + field.getBindingInfo().getBindingPath() + methodKey);
966 methodKey++;
967 } else {
968
969 if (StringUtils.isNotEmpty(validCharactersConstraint.getMessageKey())) {
970 field.getControl().addStyleClass(validCharactersConstraint.getMessageKey());
971 }
972 }
973 }
974
975 CaseConstraint caseConstraint = ConstraintStateUtils.getApplicableConstraint(field.getCaseConstraint(),
976 validationState, stateMapping);
977 if (caseConstraint != null && caseConstraint.getApplyClientSide()) {
978 processCaseConstraint(field, view, caseConstraint, null, validationState, stateMapping);
979 }
980
981 if (field.getDependencyConstraints() != null) {
982 for (PrerequisiteConstraint prc : field.getDependencyConstraints()) {
983 prc = ConstraintStateUtils.getApplicableConstraint(prc, validationState, stateMapping);
984 if (prc != null) {
985 processPrerequisiteConstraint(field, prc, view);
986 }
987 }
988 }
989
990 if (field.getMustOccurConstraints() != null) {
991 for (MustOccurConstraint mc : field.getMustOccurConstraints()) {
992 mc = ConstraintStateUtils.getApplicableConstraint(mc, validationState, stateMapping);
993 if (mc != null) {
994 processMustOccurConstraint(field, view, mc, "true");
995 }
996 }
997 }
998
999 }
1000 }
1001
1002 }