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