source: ether_megapoli/trunk/web/WEB-INF/validator-rules.xml @ 373

Last change on this file since 373 was 140, checked in by vmipsl, 13 years ago

Import medias files and cleanup
File size: 40.3 KB
Line 
1<!DOCTYPE form-validation PUBLIC
2          "-//Apache Software Foundation//DTD Commons Validator Rules Configuration 1.0//EN"
3          "http://jakarta.apache.org/commons/dtds/validator_1_0.dtd">
4<!--
5
6   This file contains the default Struts Validator pluggable validator
7   definitions.  It should be placed somewhere under /WEB-INF and
8   referenced in the struts-config.xml under the plug-in element
9   for the ValidatorPlugIn.
10
11      <plug-in className="org.apache.struts.validator.ValidatorPlugIn">
12        <set-property property="pathnames" value="/WEB-INF/validator-rules.xml,
13                                                  /WEB-INF/validation.xml"/>
14      </plug-in>
15
16   These are the default error messages associated with
17   each validator defined in this file.  They should be
18   added to your projects ApplicationResources.properties
19   file or you can associate new ones by modifying the
20   pluggable validators msg attributes in this file.
21
22   # Struts Validator Error Messages
23   errors.required={0} is required.
24   errors.minlength={0} can not be less than {1} characters.
25   errors.maxlength={0} can not be greater than {1} characters.
26   errors.invalid={0} is invalid.
27
28   errors.byte={0} must be a byte.
29   errors.short={0} must be a short.
30   errors.integer={0} must be an integer.
31   errors.long={0} must be a long.
32   errors.float={0} must be a float.
33   errors.double={0} must be a double.
34
35   errors.date={0} is not a date.
36   errors.range={0} is not in the range {1} through {2}.
37   errors.creditcard={0} is an invalid credit card number.
38   errors.email={0} is an invalid e-mail address.
39
40-->
41
42<form-validation>
43
44   <global>
45
46      <validator name="required"
47            classname="org.apache.struts.validator.FieldChecks"
48               method="validateRequired"
49         methodParams="java.lang.Object,
50                       org.apache.commons.validator.ValidatorAction,
51                       org.apache.commons.validator.Field,
52                       org.apache.struts.action.ActionErrors,
53                       javax.servlet.http.HttpServletRequest"
54                  msg="errors.required">
55
56         <javascript><![CDATA[
57            function validateRequired(form) {
58                var isValid = true;
59                var focusField = null;
60                var i = 0;
61                var fields = new Array();
62                oRequired = new required();
63                for (x in oRequired) {
64                        var field = form[oRequired[x][0]];
65                       
66                    if (field.type == 'text' ||
67                        field.type == 'textarea' ||
68                        field.type == 'file' ||
69                        field.type == 'select-one' ||
70                        field.type == 'radio' ||
71                        field.type == 'password') {
72                       
73                        var value = '';
74                                                // get field's value
75                                                if (field.type == "select-one") {
76                                                        var si = field.selectedIndex;
77                                                        if (si >= 0) {
78                                                                value = field.options[si].value;
79                                                        }
80                                                } else {
81                                                        value = field.value;
82                                                }
83                       
84                        if (trim(value).length == 0) {
85                       
86                                if (i == 0) {
87                                    focusField = field;
88                                }
89                                fields[i++] = oRequired[x][1];
90                                isValid = false;
91                        }
92                    }
93                }
94                if (fields.length > 0) {
95                   focusField.focus();
96                   alert(fields.join('\n'));
97                }
98                return isValid;
99            }
100           
101            // Trim whitespace from left and right sides of s.
102            function trim(s) {
103                return s.replace( /^\s*/, "" ).replace( /\s*$/, "" );
104            }
105           
106            ]]>
107         </javascript>
108
109      </validator>
110
111      <validator name="requiredif"
112                 classname="org.apache.struts.validator.FieldChecks"
113                 method="validateRequiredIf"
114                 methodParams="java.lang.Object,
115                               org.apache.commons.validator.ValidatorAction,
116                               org.apache.commons.validator.Field,
117                               org.apache.struts.action.ActionErrors,
118                               org.apache.commons.validator.Validator,
119                               javax.servlet.http.HttpServletRequest"
120                 msg="errors.required">
121      </validator>
122
123      <validator name="minlength"
124            classname="org.apache.struts.validator.FieldChecks"
125               method="validateMinLength"
126         methodParams="java.lang.Object,
127                       org.apache.commons.validator.ValidatorAction,
128                       org.apache.commons.validator.Field,
129                       org.apache.struts.action.ActionErrors,
130                       javax.servlet.http.HttpServletRequest"
131              depends=""
132                  msg="errors.minlength">
133
134         <javascript><![CDATA[
135            function validateMinLength(form) {
136                var isValid = true;
137                var focusField = null;
138                var i = 0;
139                var fields = new Array();
140                oMinLength = new minlength();
141                for (x in oMinLength) {
142                    var field = form[oMinLength[x][0]];
143                   
144                    if (field.type == 'text' ||
145                        field.type == 'textarea') {
146                       
147                        var iMin = parseInt(oMinLength[x][2]("minlength"));
148                        if ((trim(field.value).length > 0) && (field.value.length < iMin)) {
149                            if (i == 0) {
150                                focusField = field;
151                            }
152                            fields[i++] = oMinLength[x][1];
153                            isValid = false;
154                        }
155                    }
156                }
157                if (fields.length > 0) {
158                   focusField.focus();
159                   alert(fields.join('\n'));
160                }
161                return isValid;
162            }]]>
163         </javascript>
164
165      </validator>
166
167
168      <validator name="maxlength"
169            classname="org.apache.struts.validator.FieldChecks"
170               method="validateMaxLength"
171         methodParams="java.lang.Object,
172                       org.apache.commons.validator.ValidatorAction,
173                       org.apache.commons.validator.Field,
174                       org.apache.struts.action.ActionErrors,
175                       javax.servlet.http.HttpServletRequest"
176              depends=""
177                  msg="errors.maxlength">
178
179         <javascript><![CDATA[
180            function validateMaxLength(form) {
181                var isValid = true;
182                var focusField = null;
183                var i = 0;
184                var fields = new Array();
185                oMaxLength = new maxlength();
186                for (x in oMaxLength) {
187                    var field = form[oMaxLength[x][0]];
188                   
189                    if (field.type == 'text' ||
190                        field.type == 'textarea') {
191                       
192                        var iMax = parseInt(oMaxLength[x][2]("maxlength"));
193                        if (field.value.length > iMax) {
194                            if (i == 0) {
195                                focusField = field;
196                            }
197                            fields[i++] = oMaxLength[x][1];
198                            isValid = false;
199                        }
200                    }
201                }
202                if (fields.length > 0) {
203                   focusField.focus();
204                   alert(fields.join('\n'));
205                }
206                return isValid;
207            }]]>
208         </javascript>
209
210      </validator>
211
212
213      <validator name="mask"
214            classname="org.apache.struts.validator.FieldChecks"
215               method="validateMask"
216         methodParams="java.lang.Object,
217                       org.apache.commons.validator.ValidatorAction,
218                       org.apache.commons.validator.Field,
219                       org.apache.struts.action.ActionErrors,
220                       javax.servlet.http.HttpServletRequest"
221              depends=""
222                  msg="errors.invalid">
223
224         <javascript><![CDATA[
225            function validateMask(form) {
226                var isValid = true;
227                var focusField = null;
228                var i = 0;
229                var fields = new Array();
230                oMasked = new mask();
231                for (x in oMasked) {
232                    var field = form[oMasked[x][0]];
233                   
234                    if ((field.type == 'text' ||
235                         field.type == 'textarea') &&
236                         (field.value.length > 0)) {
237                       
238                        if (!matchPattern(field.value, oMasked[x][2]("mask"))) {
239                            if (i == 0) {
240                                focusField = field;
241                            }
242                            fields[i++] = oMasked[x][1];
243                            isValid = false;
244                        }
245                    }
246                }
247               
248                if (fields.length > 0) {
249                   focusField.focus();
250                   alert(fields.join('\n'));
251                }
252                return isValid;
253            }
254
255            function matchPattern(value, mask) {
256               return mask.exec(value);
257            }]]>
258         </javascript>
259
260      </validator>
261
262
263      <validator name="byte"
264            classname="org.apache.struts.validator.FieldChecks"
265               method="validateByte"
266         methodParams="java.lang.Object,
267                       org.apache.commons.validator.ValidatorAction,
268                       org.apache.commons.validator.Field,
269                       org.apache.struts.action.ActionErrors,
270                       javax.servlet.http.HttpServletRequest"
271              depends=""
272                  msg="errors.byte"
273       jsFunctionName="ByteValidations">
274
275         <javascript><![CDATA[
276            function validateByte(form) {
277                var bValid = true;
278                var focusField = null;
279                var i = 0;
280                var fields = new Array();
281                oByte = new ByteValidations();
282                for (x in oByte) {
283                        var field = form[oByte[x][0]];
284                       
285                    if (field.type == 'text' ||
286                        field.type == 'textarea' ||
287                        field.type == 'select-one' ||
288                                                field.type == 'radio') {
289
290                                                var value = '';
291                                                // get field's value
292                                                if (field.type == "select-one") {
293                                                        var si = field.selectedIndex;
294                                                        if (si >= 0) {
295                                                                value = field.options[si].value;
296                                                        }
297                                                } else {
298                                                        value = field.value;
299                                                }
300                       
301                        if (value.length > 0) {
302                            if (!isAllDigits(value)) {
303                                bValid = false;
304                                if (i == 0) {
305                                    focusField = field;
306                                }
307                                fields[i++] = oByte[x][1];
308
309                            } else {
310
311                                    var iValue = parseInt(value);
312                                    if (isNaN(iValue) || !(iValue >= -128 && iValue <= 127)) {
313                                        if (i == 0) {
314                                            focusField = field;
315                                        }
316                                        fields[i++] = oByte[x][1];
317                                        bValid = false;
318                                    }
319                            }
320                                                }
321                                               
322                    }
323                }
324                if (fields.length > 0) {
325                   focusField.focus();
326                   alert(fields.join('\n'));
327                }
328                return bValid;
329            }]]>
330         </javascript>
331
332      </validator>
333
334
335      <validator name="short"
336            classname="org.apache.struts.validator.FieldChecks"
337               method="validateShort"
338         methodParams="java.lang.Object,
339                       org.apache.commons.validator.ValidatorAction,
340                       org.apache.commons.validator.Field,
341                       org.apache.struts.action.ActionErrors,
342                       javax.servlet.http.HttpServletRequest"
343              depends=""
344                  msg="errors.short"
345       jsFunctionName="ShortValidations">
346
347         <javascript><![CDATA[
348            function validateShort(form) {
349                var bValid = true;
350                var focusField = null;
351                var i = 0;
352                var fields = new Array();
353                oShort = new ShortValidations();
354                for (x in oShort) {
355                        var field = form[oShort[x][0]];
356                       
357                    if (field.type == 'text' ||
358                        field.type == 'textarea' ||
359                        field.type == 'select-one' ||
360                        field.type == 'radio') {
361                       
362                        var value = '';
363                                                // get field's value
364                                                if (field.type == "select-one") {
365                                                        var si = field.selectedIndex;
366                                                        if (si >= 0) {
367                                                                value = field.options[si].value;
368                                                        }
369                                                } else {
370                                                        value = field.value;
371                                                }
372                       
373                        if (value.length > 0) {
374                            if (!isAllDigits(value)) {
375                                bValid = false;
376                                if (i == 0) {
377                                    focusField = field;
378                                }
379                                fields[i++] = oShort[x][1];
380
381                            } else {
382                       
383                                    var iValue = parseInt(value);
384                                    if (isNaN(iValue) || !(iValue >= -32768 && iValue <= 32767)) {
385                                        if (i == 0) {
386                                            focusField = field;
387                                        }
388                                        fields[i++] = oShort[x][1];
389                                        bValid = false;
390                                    }
391                               }
392                       }
393                    }
394                }
395                if (fields.length > 0) {
396                   focusField.focus();
397                   alert(fields.join('\n'));
398                }
399                return bValid;
400            }]]>
401         </javascript>
402
403      </validator>
404
405
406      <validator name="integer"
407            classname="org.apache.struts.validator.FieldChecks"
408               method="validateInteger"
409         methodParams="java.lang.Object,
410                       org.apache.commons.validator.ValidatorAction,
411                       org.apache.commons.validator.Field,
412                       org.apache.struts.action.ActionErrors,
413                       javax.servlet.http.HttpServletRequest"
414              depends=""
415                  msg="errors.integer"
416       jsFunctionName="IntegerValidations">
417
418         <javascript><![CDATA[
419            function validateInteger(form) {
420                var bValid = true;
421                var focusField = null;
422                var i = 0;
423                var fields = new Array();
424                oInteger = new IntegerValidations();
425                for (x in oInteger) {
426                        var field = form[oInteger[x][0]];
427
428                    if (field.type == 'text' ||
429                        field.type == 'textarea' ||
430                        field.type == 'select-one' ||
431                        field.type == 'radio') {
432                       
433                        var value = '';
434                                                // get field's value
435                                                if (field.type == "select-one") {
436                                                        var si = field.selectedIndex;
437                                                    if (si >= 0) {
438                                                            value = field.options[si].value;
439                                                    }
440                                                } else {
441                                                        value = field.value;
442                                                }
443                       
444                        if (value.length > 0) {
445                       
446                            if (!isAllDigits(value)) {
447                                bValid = false;
448                                if (i == 0) {
449                                        focusField = field;
450                                    }
451                                                        fields[i++] = oInteger[x][1];
452                                                       
453                            } else {
454                                    var iValue = parseInt(value);
455                                    if (isNaN(iValue) || !(iValue >= -2147483648 && iValue <= 2147483647)) {
456                                        if (i == 0) {
457                                            focusField = field;
458                                        }
459                                        fields[i++] = oInteger[x][1];
460                                        bValid = false;
461                                   }
462                           }
463                       }
464                    }
465                }
466                if (fields.length > 0) {
467                   focusField.focus();
468                   alert(fields.join('\n'));
469                }
470                return bValid;
471            }
472
473            function isAllDigits(argvalue) {
474                argvalue = argvalue.toString();
475                var validChars = "0123456789";
476                var startFrom = 0;
477                if (argvalue.substring(0, 2) == "0x") {
478                   validChars = "0123456789abcdefABCDEF";
479                   startFrom = 2;
480                } else if (argvalue.charAt(0) == "0") {
481                   validChars = "01234567";
482                   startFrom = 1;
483                } else if (argvalue.charAt(0) == "-") {
484                    startFrom = 1;
485                }
486               
487                for (var n = startFrom; n < argvalue.length; n++) {
488                    if (validChars.indexOf(argvalue.substring(n, n+1)) == -1) return false;
489                }
490                return true;
491            }]]>
492         </javascript>
493
494      </validator>
495
496
497      <validator name="long"
498            classname="org.apache.struts.validator.FieldChecks"
499               method="validateLong"
500         methodParams="java.lang.Object,
501                       org.apache.commons.validator.ValidatorAction,
502                       org.apache.commons.validator.Field,
503                       org.apache.struts.action.ActionErrors,
504                       javax.servlet.http.HttpServletRequest"
505              depends=""
506                  msg="errors.long"/>
507
508
509      <validator name="float"
510            classname="org.apache.struts.validator.FieldChecks"
511               method="validateFloat"
512         methodParams="java.lang.Object,
513                       org.apache.commons.validator.ValidatorAction,
514                       org.apache.commons.validator.Field,
515                       org.apache.struts.action.ActionErrors,
516                       javax.servlet.http.HttpServletRequest"
517              depends=""
518                  msg="errors.float"
519       jsFunctionName="FloatValidations">
520
521         <javascript><![CDATA[
522            function validateFloat(form) {
523                var bValid = true;
524                var focusField = null;
525                var i = 0;
526                var fields = new Array();
527                oFloat = new FloatValidations();
528                for (x in oFloat) {
529                        var field = form[oFloat[x][0]];
530                       
531                    if (field.type == 'text' ||
532                        field.type == 'textarea' ||
533                        field.type == 'select-one' ||
534                        field.type == 'radio') {
535                       
536                        var value = '';
537                                                // get field's value
538                                                if (field.type == "select-one") {
539                                                        var si = field.selectedIndex;
540                                                        if (si >= 0) {
541                                                            value = field.options[si].value;
542                                                        }
543                                                } else {
544                                                        value = field.value;
545                                                }
546                       
547                        if (value.length > 0) {
548                            // remove '.' before checking digits
549                            var tempArray = value.split('.');
550                            var joinedString= tempArray.join('');
551
552                            if (!isAllDigits(joinedString)) {
553                                bValid = false;
554                                if (i == 0) {
555                                    focusField = field;
556                                }
557                                fields[i++] = oFloat[x][1];
558
559                            } else {
560                                    var iValue = parseFloat(value);
561                                    if (isNaN(iValue)) {
562                                        if (i == 0) {
563                                            focusField = field;
564                                        }
565                                        fields[i++] = oFloat[x][1];
566                                        bValid = false;
567                                    }
568                            }
569                        }
570                    }
571                }
572                if (fields.length > 0) {
573                   focusField.focus();
574                   alert(fields.join('\n'));
575                }
576                return bValid;
577            }]]>
578         </javascript>
579
580      </validator>
581
582
583      <validator name="double"
584            classname="org.apache.struts.validator.FieldChecks"
585               method="validateDouble"
586         methodParams="java.lang.Object,
587                       org.apache.commons.validator.ValidatorAction,
588                       org.apache.commons.validator.Field,
589                       org.apache.struts.action.ActionErrors,
590                       javax.servlet.http.HttpServletRequest"
591              depends=""
592                  msg="errors.double"/>
593
594
595      <validator name="date"
596            classname="org.apache.struts.validator.FieldChecks"
597               method="validateDate"
598         methodParams="java.lang.Object,
599                       org.apache.commons.validator.ValidatorAction,
600                       org.apache.commons.validator.Field,
601                       org.apache.struts.action.ActionErrors,
602                       javax.servlet.http.HttpServletRequest"
603              depends=""
604                  msg="errors.date"
605       jsFunctionName="DateValidations">
606
607         <javascript><![CDATA[
608            function validateDate(form) {
609               var bValid = true;
610               var focusField = null;
611               var i = 0;
612               var fields = new Array();
613               oDate = new DateValidations();
614               for (x in oDate) {
615                   var value = form[oDate[x][0]].value;
616                   var datePattern = oDate[x][2]("datePatternStrict");
617                   if ((form[oDate[x][0]].type == 'text' ||
618                        form[oDate[x][0]].type == 'textarea') &&
619                       (value.length > 0) &&
620                       (datePattern.length > 0)) {
621                     var MONTH = "MM";
622                     var DAY = "dd";
623                     var YEAR = "yyyy";
624                     var orderMonth = datePattern.indexOf(MONTH);
625                     var orderDay = datePattern.indexOf(DAY);
626                     var orderYear = datePattern.indexOf(YEAR);
627                     if ((orderDay < orderYear && orderDay > orderMonth)) {
628                         var iDelim1 = orderMonth + MONTH.length;
629                         var iDelim2 = orderDay + DAY.length;
630                         var delim1 = datePattern.substring(iDelim1, iDelim1 + 1);
631                         var delim2 = datePattern.substring(iDelim2, iDelim2 + 1);
632                         if (iDelim1 == orderDay && iDelim2 == orderYear) {
633                            dateRegexp = new RegExp("^(\\d{2})(\\d{2})(\\d{4})$");
634                         } else if (iDelim1 == orderDay) {
635                            dateRegexp = new RegExp("^(\\d{2})(\\d{2})[" + delim2 + "](\\d{4})$");
636                         } else if (iDelim2 == orderYear) {
637                            dateRegexp = new RegExp("^(\\d{2})[" + delim1 + "](\\d{2})(\\d{4})$");
638                         } else {
639                            dateRegexp = new RegExp("^(\\d{2})[" + delim1 + "](\\d{2})[" + delim2 + "](\\d{4})$");
640                         }
641                         var matched = dateRegexp.exec(value);
642                         if(matched != null) {
643                            if (!isValidDate(matched[2], matched[1], matched[3])) {
644                               if (i == 0) {
645                                   focusField = form[oDate[x][0]];
646                               }
647                               fields[i++] = oDate[x][1];
648                               bValid =  false;
649                            }
650                         } else {
651                            if (i == 0) {
652                                focusField = form[oDate[x][0]];
653                            }
654                            fields[i++] = oDate[x][1];
655                            bValid =  false;
656                         }
657                     } else if ((orderMonth < orderYear && orderMonth > orderDay)) {
658                         var iDelim1 = orderDay + DAY.length;
659                         var iDelim2 = orderMonth + MONTH.length;
660                         var delim1 = datePattern.substring(iDelim1, iDelim1 + 1);
661                         var delim2 = datePattern.substring(iDelim2, iDelim2 + 1);
662                         if (iDelim1 == orderMonth && iDelim2 == orderYear) {
663                             dateRegexp = new RegExp("^(\\d{2})(\\d{2})(\\d{4})$");
664                         } else if (iDelim1 == orderMonth) {
665                             dateRegexp = new RegExp("^(\\d{2})(\\d{2})[" + delim2 + "](\\d{4})$");
666                         } else if (iDelim2 == orderYear) {
667                             dateRegexp = new RegExp("^(\\d{2})[" + delim1 + "](\\d{2})(\\d{4})$");
668                         } else {
669                             dateRegexp = new RegExp("^(\\d{2})[" + delim1 + "](\\d{2})[" + delim2 + "](\\d{4})$");
670                         }
671                         var matched = dateRegexp.exec(value);
672                         if(matched != null) {
673                             if (!isValidDate(matched[1], matched[2], matched[3])) {
674                                 if (i == 0) {
675                                     focusField = form[oDate[x][0]];
676                                 }
677                                 fields[i++] = oDate[x][1];
678                                 bValid =  false;
679                              }
680                         } else {
681                             if (i == 0) {
682                                 focusField = form[oDate[x][0]];
683                             }
684                             fields[i++] = oDate[x][1];
685                             bValid =  false;
686                         }
687                     } else if ((orderMonth > orderYear && orderMonth < orderDay)) {
688                         var iDelim1 = orderYear + YEAR.length;
689                         var iDelim2 = orderMonth + MONTH.length;
690                         var delim1 = datePattern.substring(iDelim1, iDelim1 + 1);
691                         var delim2 = datePattern.substring(iDelim2, iDelim2 + 1);
692                         if (iDelim1 == orderMonth && iDelim2 == orderDay) {
693                             dateRegexp = new RegExp("^(\\d{4})(\\d{2})(\\d{2})$");
694                         } else if (iDelim1 == orderMonth) {
695                             dateRegexp = new RegExp("^(\\d{4})(\\d{2})[" + delim2 + "](\\d{2})$");
696                         } else if (iDelim2 == orderDay) {
697                             dateRegexp = new RegExp("^(\\d{4})[" + delim1 + "](\\d{2})(\\d{2})$");
698                         } else {
699                             dateRegexp = new RegExp("^(\\d{4})[" + delim1 + "](\\d{2})[" + delim2 + "](\\d{2})$");
700                         }
701                         var matched = dateRegexp.exec(value);
702                         if(matched != null) {
703                             if (!isValidDate(matched[3], matched[2], matched[1])) {
704                                 if (i == 0) {
705                                     focusField = form[oDate[x][0]];
706                                  }
707                                  fields[i++] = oDate[x][1];
708                                  bValid =  false;
709                              }
710                          } else {
711                              if (i == 0) {
712                                  focusField = form[oDate[x][0]];
713                              }
714                              fields[i++] = oDate[x][1];
715                              bValid =  false;
716                          }
717                     } else {
718                         if (i == 0) {
719                             focusField = form[oDate[x][0]];
720                         }
721                         fields[i++] = oDate[x][1];
722                         bValid =  false;
723                     }
724                  }
725               }
726               if (fields.length > 0) {
727                  focusField.focus();
728                  alert(fields.join('\n'));
729               }
730               return bValid;
731            }
732
733            function isValidDate(day, month, year) {
734                if (month < 1 || month > 12) {
735                    return false;
736                }
737                if (day < 1 || day > 31) {
738                    return false;
739                }
740                if ((month == 4 || month == 6 || month == 9 || month == 11) &&
741                    (day == 31)) {
742                    return false;
743                }
744                if (month == 2) {
745                    var leap = (year % 4 == 0 &&
746                               (year % 100 != 0 || year % 400 == 0));
747                    if (day>29 || (day == 29 && !leap)) {
748                        return false;
749                    }
750                }
751                return true;
752            }]]>
753         </javascript>
754
755      </validator>
756
757<!-- range is deprecated use intRange instead -->
758      <validator name="range"
759            classname="org.apache.struts.validator.FieldChecks"
760               method="validateIntRange"
761         methodParams="java.lang.Object,
762                       org.apache.commons.validator.ValidatorAction,
763                       org.apache.commons.validator.Field,
764                       org.apache.struts.action.ActionErrors,
765                       javax.servlet.http.HttpServletRequest"
766              depends="integer"
767                  msg="errors.range">
768
769         <javascript><![CDATA[
770            function validateRange(form) {
771                return validateIntRange(form);
772            }]]>
773         </javascript>
774
775      </validator>
776
777      <validator name="intRange"
778            classname="org.apache.struts.validator.FieldChecks"
779               method="validateIntRange"
780         methodParams="java.lang.Object,
781                       org.apache.commons.validator.ValidatorAction,
782                       org.apache.commons.validator.Field,
783                       org.apache.struts.action.ActionErrors,
784                       javax.servlet.http.HttpServletRequest"
785              depends="integer"
786                  msg="errors.range">
787
788         <javascript><![CDATA[
789            function validateIntRange(form) {
790                var isValid = true;
791                var focusField = null;
792                var i = 0;
793                var fields = new Array();
794                oRange = new intRange();
795                for (x in oRange) {
796                    var field = form[oRange[x][0]];
797                   
798                    if ((field.type == 'text' ||
799                         field.type == 'textarea') &&
800                        (field.value.length > 0)) {
801                       
802                        var iMin = parseInt(oRange[x][2]("min"));
803                        var iMax = parseInt(oRange[x][2]("max"));
804                        var iValue = parseInt(field.value);
805                        if (!(iValue >= iMin && iValue <= iMax)) {
806                            if (i == 0) {
807                                focusField = field;
808                            }
809                            fields[i++] = oRange[x][1];
810                            isValid = false;
811                        }
812                    }
813                }
814                if (fields.length > 0) {
815                    focusField.focus();
816                    alert(fields.join('\n'));
817                }
818                return isValid;
819            }]]>
820         </javascript>
821
822      </validator>
823
824      <validator name="floatRange"
825            classname="org.apache.struts.validator.FieldChecks"
826               method="validateFloatRange"
827         methodParams="java.lang.Object,
828                       org.apache.commons.validator.ValidatorAction,
829                       org.apache.commons.validator.Field,
830                       org.apache.struts.action.ActionErrors,
831                       javax.servlet.http.HttpServletRequest"
832              depends="float"
833                  msg="errors.range">
834
835         <javascript><![CDATA[
836            function validateFloatRange(form) {
837                var isValid = true;
838                var focusField = null;
839                var i = 0;
840                var fields = new Array();
841                oRange = new floatRange();
842                for (x in oRange) {
843                    var field = form[oRange[x][0]];
844                   
845                    if ((field.type == 'text' ||
846                         field.type == 'textarea') &&
847                        (field.value.length > 0)) {
848                       
849                        var fMin = parseFloat(oRange[x][2]("min"));
850                        var fMax = parseFloat(oRange[x][2]("max"));
851                        var fValue = parseFloat(field.value);
852                        if (!(fValue >= fMin && fValue <= fMax)) {
853                            if (i == 0) {
854                                focusField = field;
855                            }
856                            fields[i++] = oRange[x][1];
857                            isValid = false;
858                        }
859                    }
860                }
861                if (fields.length > 0) {
862                    focusField.focus();
863                    alert(fields.join('\n'));
864                }
865                return isValid;
866            }]]>
867         </javascript>
868
869      </validator>
870
871      <validator name="creditCard"
872            classname="org.apache.struts.validator.FieldChecks"
873               method="validateCreditCard"
874         methodParams="java.lang.Object,
875                       org.apache.commons.validator.ValidatorAction,
876                       org.apache.commons.validator.Field,
877                       org.apache.struts.action.ActionErrors,
878                       javax.servlet.http.HttpServletRequest"
879              depends=""
880                  msg="errors.creditcard">
881
882         <javascript><![CDATA[
883            function validateCreditCard(form) {
884                var bValid = true;
885                var focusField = null;
886                var i = 0;
887                var fields = new Array();
888                oCreditCard = new creditCard();
889                for (x in oCreditCard) {
890                    if ((form[oCreditCard[x][0]].type == 'text' ||
891                         form[oCreditCard[x][0]].type == 'textarea') &&
892                        (form[oCreditCard[x][0]].value.length > 0)) {
893                        if (!luhnCheck(form[oCreditCard[x][0]].value)) {
894                            if (i == 0) {
895                                focusField = form[oCreditCard[x][0]];
896                            }
897                            fields[i++] = oCreditCard[x][1];
898                            bValid = false;
899                        }
900                    }
901                }
902                if (fields.length > 0) {
903                    focusField.focus();
904                    alert(fields.join('\n'));
905                }
906                return bValid;
907            }
908
909            /**
910             * Reference: http://www.ling.nwu.edu/~sburke/pub/luhn_lib.pl
911             */
912            function luhnCheck(cardNumber) {
913                if (isLuhnNum(cardNumber)) {
914                    var no_digit = cardNumber.length;
915                    var oddoeven = no_digit & 1;
916                    var sum = 0;
917                    for (var count = 0; count < no_digit; count++) {
918                        var digit = parseInt(cardNumber.charAt(count));
919                        if (!((count & 1) ^ oddoeven)) {
920                            digit *= 2;
921                            if (digit > 9) digit -= 9;
922                        };
923                        sum += digit;
924                    };
925                    if (sum == 0) return false;
926                    if (sum % 10 == 0) return true;
927                };
928                return false;
929            }
930
931            function isLuhnNum(argvalue) {
932                argvalue = argvalue.toString();
933                if (argvalue.length == 0) {
934                    return false;
935                }
936                for (var n = 0; n < argvalue.length; n++) {
937                    if ((argvalue.substring(n, n+1) < "0") ||
938                        (argvalue.substring(n,n+1) > "9")) {
939                        return false;
940                    }
941                }
942                return true;
943            }]]>
944         </javascript>
945
946      </validator>
947
948
949      <validator name="email"
950            classname="org.apache.struts.validator.FieldChecks"
951               method="validateEmail"
952         methodParams="java.lang.Object,
953                       org.apache.commons.validator.ValidatorAction,
954                       org.apache.commons.validator.Field,
955                       org.apache.struts.action.ActionErrors,
956                       javax.servlet.http.HttpServletRequest"
957              depends=""
958                  msg="errors.email">
959
960         <javascript><![CDATA[
961            function validateEmail(form) {
962                var bValid = true;
963                var focusField = null;
964                var i = 0;
965                var fields = new Array();
966                oEmail = new email();
967                for (x in oEmail) {
968                    if ((form[oEmail[x][0]].type == 'text' ||
969                         form[oEmail[x][0]].type == 'textarea') &&
970                        (form[oEmail[x][0]].value.length > 0)) {
971                        if (!checkEmail(form[oEmail[x][0]].value)) {
972                            if (i == 0) {
973                                focusField = form[oEmail[x][0]];
974                            }
975                            fields[i++] = oEmail[x][1];
976                            bValid = false;
977                        }
978                    }
979                }
980                if (fields.length > 0) {
981                    focusField.focus();
982                    alert(fields.join('\n'));
983                }
984                return bValid;
985            }
986
987            /**
988             * Reference: Sandeep V. Tamhankar (stamhankar@hotmail.com),
989             * http://javascript.internet.com
990             */
991            function checkEmail(emailStr) {
992               if (emailStr.length == 0) {
993                   return true;
994               }
995               var emailPat=/^(.+)@(.+)$/;
996               var specialChars="\\(\\)<>@,;:\\\\\\\"\\.\\[\\]";
997               var validChars="\[^\\s" + specialChars + "\]";
998               var quotedUser="(\"[^\"]*\")";
999               var ipDomainPat=/^(\d{1,3})[.](\d{1,3})[.](\d{1,3})[.](\d{1,3})$/;
1000               var atom=validChars + '+';
1001               var word="(" + atom + "|" + quotedUser + ")";
1002               var userPat=new RegExp("^" + word + "(\\." + word + ")*$");
1003               var domainPat=new RegExp("^" + atom + "(\\." + atom + ")*$");
1004               var matchArray=emailStr.match(emailPat);
1005               if (matchArray == null) {
1006                   return false;
1007               }
1008               var user=matchArray[1];
1009               var domain=matchArray[2];
1010               if (user.match(userPat) == null) {
1011                   return false;
1012               }
1013               var IPArray = domain.match(ipDomainPat);
1014               if (IPArray != null) {
1015                   for (var i = 1; i <= 4; i++) {
1016                      if (IPArray[i] > 255) {
1017                         return false;
1018                      }
1019                   }
1020                   return true;
1021               }
1022               var domainArray=domain.match(domainPat);
1023               if (domainArray == null) {
1024                   return false;
1025               }
1026               var atomPat=new RegExp(atom,"g");
1027               var domArr=domain.match(atomPat);
1028               var len=domArr.length;
1029               if ((domArr[domArr.length-1].length < 2) ||
1030                   (domArr[domArr.length-1].length > 3)) {
1031                   return false;
1032               }
1033               if (len < 2) {
1034                   return false;
1035               }
1036               return true;
1037            }]]>
1038         </javascript>
1039
1040      </validator>
1041
1042   </global>
1043
1044</form-validation>
Note: See TracBrowser for help on using the repository browser.